niahere 0.3.10 → 0.3.12

package/README.md

@@ -86,7 +86,8 @@ nia agent show <name>          — show agent details and prompt
 nia skills [source]            — list available skills
 
 nia channels                   — show channel status (on/off)
-nia channels on / off          — enable/disable channels (applied via SIGHUP, no restart)
+nia channels on / off          — enable/disable all channels (applied via SIGHUP, no restart)
+nia channels off telegram      — disable one channel without removing its token
 nia watch list                 — list Slack watch channels
 nia watch add/remove/enable/disable — manage watch channels
 

package/package.json

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

package/src/channels/index.ts

@@ -1,6 +1,7 @@
 import type { Channel } from "../types";
 import { registerChannel, getFactories, trackStarted, clearStarted } from "./registry";
 import { log } from "../utils/log";
+import { getConfig } from "../utils/config";
 import { createTelegramChannel } from "./telegram";
 import { createSlackChannel } from "./slack";
 import { createPhoneChannel } from "./phone";
@@ -59,6 +60,24 @@ export async function startChannels(): Promise<StartResult> {
   return { started, failed };
 }
 
+export function getConfiguredChannelNames(): string[] {
+  const { channels } = getConfig();
+  if (!channels.enabled) return [];
+
+  const names: string[] = [];
+  if (channels.telegram.enabled && channels.telegram.bot_token) names.push("telegram");
+  if (channels.slack.enabled && channels.slack.bot_token && channels.slack.app_token) names.push("slack");
+  if (channels.phone.enabled && channels.twilio.sid && channels.twilio.secret && channels.phone.from_number) {
+    names.push("phone");
+  }
+  const smsFromNumber = channels.sms.from_number ?? channels.phone.from_number;
+  if (channels.sms.enabled && channels.twilio.sid && channels.twilio.secret && smsFromNumber) names.push("sms");
+  if (channels.whatsapp.enabled && channels.twilio.sid && channels.twilio.secret && channels.whatsapp.from_number) {
+    names.push("whatsapp");
+  }
+  return names;
+}
+
 export async function stopChannels(channels: Channel[]): Promise<void> {
   const results = await Promise.allSettled(
     channels.map(async (channel) => {

package/src/channels/slack.ts

@@ -15,6 +15,21 @@ function cleanSentinel(text: string): string {
   return text.replace(/`/g, "").trim();
 }
 
+interface SlackReactionClient {
+  reactions: {
+    add(args: { channel: string; timestamp: string; name: string }): Promise<unknown>;
+  };
+}
+
+export async function reactToSlackMessage(
+  client: SlackReactionClient,
+  channel: string,
+  timestamp: string,
+  name: string,
+): Promise<void> {
+  await client.reactions.add({ channel, timestamp, name });
+}
+
 class SlackChannel implements Channel {
   name = "slack" as const;
   private app: App | null = null;
@@ -415,12 +430,11 @@ class SlackChannel implements Channel {
         }
 
         // Add thinking reaction inside the lock so cleanup is guaranteed
-        await client.reactions
-          .add({ channel: msg.channel, timestamp: msg.ts, name: "thinking_face" })
+        await reactToSlackMessage(client, msg.channel, msg.ts, "thinking_face")
           .catch((err) => log.debug({ err, channel: msg.channel }, "slack: failed to add thinking reaction"));
 
         try {
-          const { result, messageId } = await state.engine.send(
+          const { result, messageId, signal } = await state.engine.send(
             text,
             {
               onActivity(status) {
@@ -430,6 +444,15 @@ class SlackChannel implements Channel {
             attachments,
           );
 
+          if (signal === "provider_down") {
+            await reactToSlackMessage(client, msg.channel, msg.ts, "skull").catch((err) =>
+              log.debug({ err, channel: msg.channel }, "slack: failed to add provider-down reaction"),
+            );
+            if (messageId) await Message.updateDeliveryStatus(messageId, "sent").catch(() => {});
+            log.info({ channel: msg.channel, key, reaction: "skull" }, "slack provider failure sent as reaction");
+            return;
+          }
+
           const reply = result.trim();
           const cleaned = cleanSentinel(reply);
 
@@ -517,6 +540,8 @@ class SlackChannel implements Channel {
 
 export function createSlackChannel(): SlackChannel | null {
   const config = getConfig();
-  if (!config.channels.slack.bot_token || !config.channels.slack.app_token) return null;
+  if (!config.channels.slack.enabled || !config.channels.slack.bot_token || !config.channels.slack.app_token) {
+    return null;
+  }
   return new SlackChannel();
 }

package/src/channels/telegram.ts

@@ -286,6 +286,7 @@ class TelegramChannel implements Channel {
 }
 
 export function createTelegramChannel(): TelegramChannel | null {
-  if (!getConfig().channels.telegram.bot_token) return null;
+  const telegram = getConfig().channels.telegram;
+  if (!telegram.enabled || !telegram.bot_token) return null;
   return new TelegramChannel();
 }

package/src/chat/engine.ts

@@ -33,8 +33,7 @@ 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.";
+const GENERIC_CHAT_ERROR = "💀";
 
 interface SDKUserMessage {
   type: "user";
@@ -102,7 +101,7 @@ export function buildContentBlocks(text: string, attachments?: Attachment[]): Me
 /** 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") {
+  if (getChatErrorSignal(error) === "provider_down") {
     return GENERIC_CHAT_ERROR;
   }
   if (error === "oauth_org_not_allowed") {
@@ -111,6 +110,11 @@ export function formatChatError(rawError: string | null | undefined): string {
   return `[error] ${error}`;
 }
 
+export function getChatErrorSignal(rawError: string | null | undefined): SendResult["signal"] | undefined {
+  const error = rawError?.trim();
+  return !error || error.toLowerCase() === "unknown error" ? "provider_down" : undefined;
+}
+
 export function resolveSdkModel(contextModel?: string | null): string | undefined {
   const model = contextModel || getConfig().model;
   return model && model !== "default" ? model : undefined;
@@ -560,7 +564,7 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
                 );
                 await ActiveEngine.unregister(room);
                 clearLongRunningTimer();
-                pending.resolve({ result: errorText, costUsd: 0, turns: 0 });
+                pending.resolve({ result: errorText, costUsd: 0, turns: 0, signal: getChatErrorSignal(rawError) });
                 pending = null;
                 retryCount = 0;
                 resetIdleTimer();

package/src/cli/index.ts

@@ -49,8 +49,10 @@ async function awaitStartup(timeout = 60_000): Promise<void> {
   const config = getConfig();
   const expecting = new Set<string>();
   if (config.channels.enabled) {
-    if (config.channels.telegram.bot_token) expecting.add("telegram");
-    if (config.channels.slack.bot_token && config.channels.slack.app_token) expecting.add("slack");
+    if (config.channels.telegram.enabled && config.channels.telegram.bot_token) expecting.add("telegram");
+    if (config.channels.slack.enabled && config.channels.slack.bot_token && config.channels.slack.app_token) {
+      expecting.add("slack");
+    }
   }
   expecting.add("scheduler");
 
@@ -445,16 +447,29 @@ switch (command) {
 
   case "channels": {
     const sub = process.argv[3];
+    const target = process.argv[4];
     const { updateRawConfig } = await import("../utils/config");
     if (sub === "on" || sub === "off") {
       const enabled = sub === "on";
-      updateRawConfig({ channels: { enabled } });
+      if (target) {
+        const supported = new Set(["telegram", "slack", "phone", "sms", "whatsapp"]);
+        if (!supported.has(target)) fail("Usage: nia channels <on|off> [telegram|slack|phone|sms|whatsapp]");
+        updateRawConfig({ channels: { ...(enabled ? { enabled: true } : {}), [target]: { enabled } } });
+      } else {
+        updateRawConfig({ channels: { enabled } });
+      }
       const pid = readPid();
       if (pid && isRunning()) {
         process.kill(pid, "SIGHUP");
-        console.log(`channels ${enabled ? "enabled" : "disabled"}`);
+        console.log(
+          target ? `${target} ${enabled ? "enabled" : "disabled"}` : `channels ${enabled ? "enabled" : "disabled"}`,
+        );
       } else {
-        console.log(`channels ${enabled ? "enabled" : "disabled"} — start nia to apply`);
+        console.log(
+          target
+            ? `${target} ${enabled ? "enabled" : "disabled"} — start nia to apply`
+            : `channels ${enabled ? "enabled" : "disabled"} — start nia to apply`,
+        );
       }
     } else {
       console.log(`channels: ${getConfig().channels.enabled ? "on" : "off"}`);
@@ -605,7 +620,7 @@ Persona:
   skills [source]                 List available skills
 
 Channels:
-  channels [on|off]               Toggle channels
+  channels [on|off] [name]        Toggle all channels or one channel
   watch <sub>                     Manage Slack watch channels
   telegram [setup]                Configure telegram
   slack [setup]                   Configure slack

package/src/cli/status.ts

@@ -84,7 +84,7 @@ export async function statusCommand(argv: string[] = []): Promise<void> {
       configured: Boolean(config.channels.telegram.bot_token),
       status: !config.channels.telegram.bot_token
         ? "not configured"
-        : !config.channels.enabled
+        : !config.channels.enabled || !config.channels.telegram.enabled
           ? "disabled"
           : running
             ? "active"
@@ -96,7 +96,7 @@ export async function statusCommand(argv: string[] = []): Promise<void> {
       appTokenConfigured: Boolean(config.channels.slack.app_token),
       status: !config.channels.slack.bot_token
         ? "not configured"
-        : !config.channels.enabled
+        : !config.channels.enabled || !config.channels.slack.enabled
           ? "disabled"
           : running
             ? config.channels.slack.app_token

package/src/commands/validate.ts

@@ -114,6 +114,7 @@ export function validateConfig(): Result {
     // Telegram
     const tg = ch.telegram as Record<string, unknown> | undefined;
     if (tg) {
+      if (tg.enabled === false) messages.push(`${WARN} telegram disabled`);
       if (tg.bot_token) {
         messages.push(`${PASS} telegram.bot_token set`);
       } else {
@@ -124,6 +125,7 @@ export function validateConfig(): Result {
     // Slack
     const sl = ch.slack as Record<string, unknown> | undefined;
     if (sl) {
+      if (sl.enabled === false) messages.push(`${WARN} slack disabled`);
       if (!sl.bot_token) {
         messages.push(`${WARN} slack.bot_token missing — slack won't start`);
       } else {

package/src/core/daemon.ts

@@ -8,7 +8,7 @@ import { isRunning, readPid, removePid, writePid } from "../utils/pid";
 import { ActiveEngine, Job } from "../db/models";
 import { runMigrations } from "../db/migrate";
 import { closeDb, getSql } from "../db/connection";
-import { registerAllChannels, startChannels, stopChannels, getStarted } from "../channels";
+import { registerAllChannels, startChannels, stopChannels, getStarted, getConfiguredChannelNames } from "../channels";
 import type { Channel } from "../types";
 import { startScheduler, stopScheduler, recomputeAllNextRuns } from "./scheduler";
 import { startAlive, stopAlive } from "./alive";
@@ -346,11 +346,16 @@ export async function runDaemon(): Promise<void> {
   process.on("SIGHUP", async () => {
     log.info("received SIGHUP, reloading config");
     resetConfig();
-    const fresh = getConfig();
 
     const running = getStarted();
-    const wantChannels = fresh.channels.enabled;
+    const wantedNames = getConfiguredChannelNames();
+    const runningNames = running.map((channel) => channel.name).sort();
+    const wantChannels = wantedNames.length > 0;
     const haveChannels = running.length > 0;
+    const needsReconcile =
+      wantChannels &&
+      haveChannels &&
+      (wantedNames.length !== runningNames.length || wantedNames.sort().some((name, i) => name !== runningNames[i]));
 
     if (wantChannels && !haveChannels) {
       log.info("SIGHUP: starting channels");
@@ -360,6 +365,11 @@ export async function runDaemon(): Promise<void> {
       log.info("SIGHUP: stopping channels");
       await stopChannels(running);
       channels = [];
+    } else if (needsReconcile) {
+      log.info({ wantedNames, runningNames }, "SIGHUP: reconciling channels");
+      await stopChannels(running);
+      const result = await startChannels();
+      channels = result.started;
     }
 
     await recomputeAllNextRuns().catch(() => {});

package/src/types/config.ts

@@ -1,4 +1,5 @@
 export interface TelegramConfig {
+  enabled: boolean;
   bot_token: string | null;
   chat_id: number | null;
   open: boolean;
@@ -17,6 +18,7 @@ export interface SlackWatchChannel {
 }
 
 export interface SlackConfig {
+  enabled: boolean;
   bot_token: string | null;
   app_token: string | null;
   dm_user_id: string | null;

package/src/types/engine.ts

@@ -2,6 +2,8 @@ export interface SendResult {
   result: string;
   costUsd: number;
   turns: number;
+  /** Optional channel-level signal for transports with richer UI than plain text. */
+  signal?: "provider_down";
   /** DB message ID for delivery status tracking (only set for agent replies) */
   messageId?: number;
 }

package/src/utils/config.ts

@@ -24,8 +24,9 @@ const DEFAULTS: Config = {
   channels: {
     enabled: true,
     default: "telegram",
-    telegram: { bot_token: null, chat_id: null, open: false },
+    telegram: { enabled: true, bot_token: null, chat_id: null, open: false },
     slack: {
+      enabled: true,
       bot_token: null,
       app_token: null,
       dm_user_id: null,
@@ -157,6 +158,8 @@ export function loadConfig(): Config {
   const defaultChannel = typeof ch.default === "string" ? ch.default : DEFAULTS.channels.default;
 
   // Telegram — env vars override config
+  const tgEnabled = chTg.enabled !== false;
+
   const tgBotToken = process.env.TELEGRAM_BOT_TOKEN || (typeof chTg.bot_token === "string" ? chTg.bot_token : null);
 
   const tgChatId =
@@ -166,6 +169,8 @@ export function loadConfig(): Config {
   const tgOpen = chTg.open === true;
 
   // Slack — env vars override config
+  const slEnabled = chSl.enabled !== false;
+
   const slBotToken = process.env.SLACK_BOT_TOKEN || (typeof chSl.bot_token === "string" ? chSl.bot_token : null);
 
   const slAppToken = process.env.SLACK_APP_TOKEN || (typeof chSl.app_token === "string" ? chSl.app_token : null);
@@ -254,8 +259,9 @@ export function loadConfig(): Config {
     channels: {
       enabled: channelsEnabled,
       default: defaultChannel,
-      telegram: { bot_token: tgBotToken, chat_id: tgChatId, open: tgOpen },
+      telegram: { enabled: tgEnabled, bot_token: tgBotToken, chat_id: tgChatId, open: tgOpen },
       slack: {
+        enabled: slEnabled,
         bot_token: slBotToken,
         app_token: slAppToken,
         dm_user_id: slDmUserId,