niahere 0.2.26 → 0.2.28

package/package.json

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

package/src/channels/slack.ts

@@ -512,15 +512,17 @@ class SlackChannel implements Channel {
     const rawWatchConfig = config.channels.slack.watch;
     if (rawWatchConfig) {
       for (const [key, cfg] of Object.entries(rawWatchConfig)) {
+        if (!cfg.enabled) {
+          log.info({ channel: key }, "slack: watch channel disabled, skipping");
+          continue;
+        }
         const hashIdx = key.indexOf("#");
         if (hashIdx !== -1) {
-          // channel_id#channel_name format — use ID directly, no API call needed
           const id = key.slice(0, hashIdx);
           const name = key.slice(hashIdx + 1);
           watchChannels.set(id, { name, behavior: cfg.behavior });
           log.info({ channel: name, id }, "slack: watching channel");
         } else {
-          // Legacy: plain channel name — resolve via API
           try {
             const channelList: { id: string; name: string }[] = [];
             let cursor: string | undefined;

package/src/cli/index.ts

@@ -13,6 +13,7 @@ import { jobCommand } from "./job";
 import { statusCommand } from "./status";
 import { sendCommand, telegramCommand, slackCommand } from "./channels";
 import { rulesCommand, memoryCommand } from "./self";
+import { watchCommand } from "./watch";
 
 // Set LOG_LEVEL from config before anything else logs
 try {
@@ -216,6 +217,11 @@ switch (command) {
     break;
   }
 
+  case "watch": {
+    watchCommand();
+    break;
+  }
+
   case "history": {
     const room = process.argv[3];
     try {
@@ -440,6 +446,7 @@ switch (command) {
     console.log("  memory [show|reset] — view or reset memory.md");
     console.log("  db <sub>            — database setup/status/migrate");
     console.log("  skills              — list available skills");
+    console.log("  watch <sub>         — manage Slack watch channels");
     console.log("  validate            — validate config.yaml");
     console.log("  config <sub>        — get/set/list config values");
     console.log("  send [-c ch] <msg>  — send a message via channel");

package/src/cli/watch.ts

@@ -0,0 +1,71 @@
+import { readRawConfig } from "../utils/config";
+import { addWatchChannel, removeWatchChannel, enableWatchChannel, disableWatchChannel } from "../mcp/tools";
+import { fail, ICON_PASS, ICON_FAIL } from "../utils/cli";
+
+export function watchCommand(): void {
+  const sub = process.argv[3];
+
+  switch (sub) {
+    case "list":
+    case undefined: {
+      const raw = readRawConfig();
+      const channels = (raw.channels || {}) as Record<string, unknown>;
+      const slack = (channels.slack || {}) as Record<string, unknown>;
+      const watch = (slack.watch || {}) as Record<string, unknown>;
+
+      const entries = Object.entries(watch);
+      if (entries.length === 0) {
+        console.log("No watch channels configured.");
+        break;
+      }
+      for (const [key, val] of entries) {
+        const cfg = val as Record<string, unknown>;
+        const enabled = cfg.enabled !== false;
+        const icon = enabled ? ICON_PASS : ICON_FAIL;
+        const behavior = typeof cfg.behavior === "string" ? cfg.behavior.slice(0, 80).replace(/\n/g, " ") : "";
+        console.log(`  ${icon} ${key}  ${behavior}${behavior.length >= 80 ? "..." : ""}`);
+      }
+      break;
+    }
+
+    case "add": {
+      const name = process.argv[4];
+      const behavior = process.argv.slice(5).join(" ");
+      if (!name || !behavior) {
+        fail('Usage: nia watch add <channel_id#name> <behavior>');
+      }
+      console.log(addWatchChannel(name, behavior));
+      break;
+    }
+
+    case "remove": {
+      const name = process.argv[4];
+      if (!name) fail("Usage: nia watch remove <channel_id#name>");
+      console.log(removeWatchChannel(name));
+      break;
+    }
+
+    case "enable": {
+      const name = process.argv[4];
+      if (!name) fail("Usage: nia watch enable <channel_id#name>");
+      console.log(enableWatchChannel(name));
+      break;
+    }
+
+    case "disable": {
+      const name = process.argv[4];
+      if (!name) fail("Usage: nia watch disable <channel_id#name>");
+      console.log(disableWatchChannel(name));
+      break;
+    }
+
+    default:
+      console.log("Usage: nia watch <list|add|remove|enable|disable>\n");
+      console.log("  list                              — list watch channels (default)");
+      console.log("  add <channel_id#name> <behavior>  — add a watch channel");
+      console.log("  remove <channel_id#name>          — remove a watch channel");
+      console.log("  enable <channel_id#name>          — enable a watch channel");
+      console.log("  disable <channel_id#name>         — disable a watch channel");
+      process.exit(sub ? 1 : 0);
+  }
+}

package/src/mcp/server.ts

@@ -105,6 +105,26 @@ export function createNiaMcpServer() {
           content: [{ type: "text" as const, text: handlers.removeWatchChannel(args.name) }],
         }),
       ),
+      tool(
+        "enable_watch_channel",
+        "Enable a disabled Slack watch channel. Requires daemon restart to take effect.",
+        {
+          name: z.string().describe("Slack channel key to enable"),
+        },
+        async (args) => ({
+          content: [{ type: "text" as const, text: handlers.enableWatchChannel(args.name) }],
+        }),
+      ),
+      tool(
+        "disable_watch_channel",
+        "Disable a Slack watch channel without removing it. Requires daemon restart to take effect.",
+        {
+          name: z.string().describe("Slack channel key to disable"),
+        },
+        async (args) => ({
+          content: [{ type: "text" as const, text: handlers.disableWatchChannel(args.name) }],
+        }),
+      ),
       tool(
         "add_rule",
         "Add a behavioral rule. Rules are loaded into every session and take effect without restart. Use for 'from now on' / 'always' / 'never' type instructions.",

package/src/mcp/tools.ts

@@ -3,7 +3,7 @@ import type { ScheduleType } from "../types";
 import { basename, join } from "path";
 import { Job, Message, Session } from "../db/models";
 import { computeInitialNextRun } from "../core/scheduler";
-import { getConfig, readRawConfig, updateRawConfig } from "../utils/config";
+import { getConfig, readRawConfig, updateRawConfig, writeRawConfig } from "../utils/config";
 import { getPaths } from "../utils/paths";
 import { getChannel } from "../channels/registry";
 import { log } from "../utils/log";
@@ -233,22 +233,46 @@ export function addWatchChannel(name: string, behavior: string): string {
   const raw = readRawConfig();
   const channels = (raw.channels || {}) as Record<string, unknown>;
   const slack = (channels.slack || {}) as Record<string, unknown>;
-  const watch = { ...((slack.watch || {}) as Record<string, unknown>), [name]: { behavior } };
+  const watch = { ...((slack.watch || {}) as Record<string, unknown>), [name]: { behavior, enabled: true } };
   updateRawConfig({ channels: { slack: { watch } } });
-  return `Watch channel "${name}" added. Restart daemon to apply.`;
+  return `Watch channel "${name}" added (enabled). Restart daemon to apply.`;
 }
 
 export function removeWatchChannel(name: string): string {
   const raw = readRawConfig();
   const channels = (raw.channels || {}) as Record<string, unknown>;
   const slack = (channels.slack || {}) as Record<string, unknown>;
-  const watch = { ...((slack.watch || {}) as Record<string, unknown>) };
+  const watch = (slack.watch || {}) as Record<string, unknown>;
   if (!watch[name]) return `Watch channel "${name}" not found.`;
   delete watch[name];
-  updateRawConfig({ channels: { slack: { watch } } });
+  writeRawConfig(raw);
   return `Watch channel "${name}" removed. Restart daemon to apply.`;
 }
 
+export function enableWatchChannel(name: string): string {
+  const raw = readRawConfig();
+  const channels = (raw.channels || {}) as Record<string, unknown>;
+  const slack = (channels.slack || {}) as Record<string, unknown>;
+  const watch = (slack.watch || {}) as Record<string, unknown>;
+  if (!watch[name]) return `Watch channel "${name}" not found.`;
+  const entry = watch[name] as Record<string, unknown>;
+  entry.enabled = true;
+  updateRawConfig({ channels: { slack: { watch } } });
+  return `Watch channel "${name}" enabled. Restart daemon to apply.`;
+}
+
+export function disableWatchChannel(name: string): string {
+  const raw = readRawConfig();
+  const channels = (raw.channels || {}) as Record<string, unknown>;
+  const slack = (channels.slack || {}) as Record<string, unknown>;
+  const watch = (slack.watch || {}) as Record<string, unknown>;
+  if (!watch[name]) return `Watch channel "${name}" not found.`;
+  const entry = watch[name] as Record<string, unknown>;
+  entry.enabled = false;
+  updateRawConfig({ channels: { slack: { watch } } });
+  return `Watch channel "${name}" disabled. Restart daemon to apply.`;
+}
+
 export function addMemory(entry: string): string {
   // Guard: reject raw logs, transcripts, and overly long entries
   const trimmed = entry.trim();

package/src/prompts/channel-slack.md

@@ -1,5 +1,9 @@
 ## Channel: Slack
 
+### Timestamps
+- Prefer relative times ("5 minutes ago", "~2 hours ago") over absolute timestamps. They're timezone-agnostic and easier to read.
+- If you must use absolute times, use the configured timezone from your environment, never raw UTC.
+
 ### Formatting
 - This is Slack, NOT markdown. Do NOT use **double asterisks** for bold — Slack renders them literally.
 - Slack bold: *bold* (single asterisks). Italic: _italic_. Code: `code`. Links: <url|text>.

package/src/prompts/environment.md

@@ -24,6 +24,7 @@ You have MCP tools for managing jobs directly — no need for shell commands:
 - **list_messages** — read recent chat history
 - **add_watch_channel** — add a Slack channel for proactive monitoring. Specify channel name and behavior prompt. Requires daemon restart.
 - **remove_watch_channel** — stop watching a Slack channel. Requires daemon restart.
+- **enable_watch_channel** / **disable_watch_channel** — toggle a watch channel on/off without removing it. Requires daemon restart.
 - **add_rule** — save a behavioral rule (loaded into every session, no restart needed). Use when told "from now on", "always", "never", or "remember to always..."
 - **add_memory** — save a factual memory (read on demand). Use when told "remember that...", or when you learn something surprising worth keeping
 

package/src/types/config.ts

@@ -6,6 +6,7 @@ export interface TelegramConfig {
 
 export interface SlackWatchChannel {
   behavior: string;
+  enabled: boolean;
 }
 
 export interface SlackConfig {

package/src/utils/config.ts

@@ -144,12 +144,13 @@ export function loadConfig(): Config {
 
   // Slack watch channels
   const rawWatch = chSl.watch as Record<string, unknown> | undefined;
-  let slWatch: Record<string, { behavior: string }> | null = null;
+  let slWatch: Record<string, { behavior: string; enabled: boolean }> | null = null;
   if (rawWatch && typeof rawWatch === "object") {
     slWatch = {};
     for (const [name, val] of Object.entries(rawWatch)) {
       if (val && typeof val === "object" && typeof (val as any).behavior === "string") {
-        slWatch[name] = { behavior: (val as any).behavior };
+        const enabled = (val as any).enabled !== false; // default true
+        slWatch[name] = { behavior: (val as any).behavior, enabled };
       }
     }
     if (Object.keys(slWatch).length === 0) slWatch = null;
@@ -199,16 +200,19 @@ function deepMerge(target: Record<string, unknown>, source: Record<string, unkno
 
 /** Deep-merge fields into config.yaml and write back atomically. */
 export function updateRawConfig(fields: Record<string, unknown>): void {
-  const { config } = getPaths();
   const raw = readRawConfig();
   deepMerge(raw, fields);
+  writeRawConfig(raw);
+}
+
+/** Write a full config object to config.yaml atomically (backup + temp + rename). */
+export function writeRawConfig(raw: Record<string, unknown>): void {
+  const { config } = getPaths();
   const dir = dirname(config);
   mkdirSync(dir, { recursive: true });
-  // Back up current config before overwriting
   if (existsSync(config)) {
     copyFileSync(config, join(dir, "config.yaml.bak"));
   }
-  // Write to temp file then rename for atomic update (prevents corruption on crash)
   const tmp = join(dir, `.config.yaml.tmp.${process.pid}`);
   writeFileSync(tmp, yaml.dump(raw, { lineWidth: -1 }));
   renameSync(tmp, config);