niahere 0.4.6 → 0.5.1

package/src/cli/index.ts

@@ -1,13 +1,9 @@
 #!/usr/bin/env bun
-import { existsSync, mkdirSync } from "fs";
+import { mkdirSync, readFileSync } from "fs";
 import { isRunning, readPid, runDaemon, startDaemon, stopDaemon } from "../core/daemon";
 import { getConfig } from "../utils/config";
-import { localTime } from "../utils/time";
 import { startRepl } from "../chat/repl";
-import { Message } from "../db/models";
-import { withDb } from "../db/with-db";
 import { getNiaHome, getPaths } from "../utils/paths";
-import { errMsg } from "../utils/errors";
 import { fail, ICON_PASS, ICON_WARN } from "../utils/cli";
 import { jobCommand } from "./job";
 import { statusCommand } from "./status";
@@ -19,7 +15,7 @@ import { rulesCommand, memoryCommand } from "./self";
 import { watchCommand } from "./watch";
 import { agentCommand } from "./agent";
 import { employeeCommand } from "./employee";
-import { guardActiveEngines, parseGuardFlags, withDefaultWait } from "../core/engine-guard";
+import { guardActiveEngines, parseGuardFlags } from "../core/engine-guard";
 
 // Set LOG_LEVEL from config before anything else logs
 try {
@@ -58,7 +54,6 @@ async function awaitStartup(timeout = 60_000): Promise<void> {
 
   if (expecting.size === 0) return;
 
-  const { readFileSync } = await import("fs");
   const ready = new Set<string>();
   let logOffset = 0;
   try {
@@ -167,80 +162,13 @@ switch (command) {
 
   case "run": {
     const prompt = process.argv.slice(3).join(" ");
-    if (prompt) {
-      const { createChatEngine } = await import("../chat/engine");
-      const { getMcpServers } = await import("../mcp");
-      const { DIM, RESET: RST, CLEAR_LINE, SPINNER: FRAMES } = await import("../utils/cli");
-      let frame = 0;
-      let statusText = "thinking";
-      let spinTimer: ReturnType<typeof setInterval> | null = null;
-      let streamedLen = 0;
-      let streaming = false;
-
-      const renderSpinner = () => {
-        process.stderr.write(`${CLEAR_LINE}${DIM}  ${FRAMES[frame]} ${statusText}${RST}`);
-        frame = (frame + 1) % FRAMES.length;
-      };
-
-      await withDb(async () => {
-        const engine = await createChatEngine({
-          room: "cli-run",
-          channel: "terminal",
-          resume: false,
-          mcpServers: getMcpServers(),
-        });
-        spinTimer = setInterval(renderSpinner, 80);
-        renderSpinner();
-
-        const { result, costUsd, turns } = await engine.send(prompt, {
-          onStream(textSoFar) {
-            if (!streaming) {
-              if (spinTimer) {
-                clearInterval(spinTimer);
-                spinTimer = null;
-              }
-              process.stderr.write("\x1b[2K\r");
-              streaming = true;
-            }
-            const chunk = textSoFar.slice(streamedLen);
-            if (chunk) {
-              process.stdout.write(chunk);
-              streamedLen = textSoFar.length;
-            }
-          },
-          onActivity(text) {
-            if (!streaming) statusText = text;
-          },
-        });
-
-        if (spinTimer) {
-          clearInterval(spinTimer);
-          spinTimer = null;
-        }
-
-        if (!streaming && result.trim()) {
-          process.stderr.write("\x1b[2K\r");
-          process.stdout.write(result.trim());
-        } else if (streaming) {
-          const rest = result.slice(streamedLen);
-          if (rest.trim()) process.stdout.write(rest);
-        } else {
-          process.stderr.write("\x1b[2K\r");
-        }
-
-        const costStr = costUsd > 0 ? `$${costUsd.toFixed(4)}` : "";
-        const turnsStr = turns > 0 ? `${turns} turn${turns !== 1 ? "s" : ""}` : "";
-        const meta = [costStr, turnsStr].filter(Boolean).join(" · ");
-        if (meta) process.stderr.write(`\n${DIM}${meta}${RST}`);
-        process.stdout.write("\n");
-
-        await engine.close();
-      });
-      process.exit(0);
-    } else {
+    if (!prompt) {
       await runDaemon();
+      break;
     }
-    break;
+    const { runPrompt } = await import("./run");
+    await runPrompt(prompt);
+    process.exit(0);
   }
 
   case "job": {
@@ -264,52 +192,14 @@ switch (command) {
   }
 
   case "history": {
-    const room = process.argv[3];
-    try {
-      await withDb(async () => {
-        const messages = await Message.getRecent(20, room);
-        if (messages.length === 0) {
-          console.log("No messages yet.");
-        } else {
-          for (const m of messages) {
-            const time = localTime(new Date(m.createdAt));
-            const prefix = m.sender === "user" ? "you" : m.sender;
-            const roomTag = room ? "" : `[${m.room}] `;
-            const snippet = m.content.length > 120 ? m.content.slice(0, 120) + "..." : m.content;
-            console.log(`  ${roomTag}${time}  ${prefix} > ${snippet.replace(/\n/g, " ")}`);
-          }
-        }
-      });
-    } catch (err) {
-      fail(`Failed: ${errMsg(err)}`);
-    }
+    const { historyCommand } = await import("./logs");
+    await historyCommand(process.argv[3]);
     break;
   }
 
   case "logs": {
-    const { daemonLog } = getPaths();
-    if (!existsSync(daemonLog)) fail("No daemon log found. Is nia running?");
-    const logArgs = process.argv.slice(3);
-    const follow = logArgs.includes("-f") || logArgs.includes("--follow");
-    // --channel <name> filters logs by channel/component via grep
-    const chIdx = logArgs.indexOf("--channel");
-    const channelFilter = chIdx !== -1 && logArgs[chIdx + 1] ? logArgs[chIdx + 1] : null;
-
-    if (channelFilter) {
-      // Pipe through grep to filter by channel name in structured logs
-      const tailArgs = follow ? ["tail", "-f", daemonLog] : ["tail", "-200", daemonLog];
-      const tail = Bun.spawn(tailArgs, {
-        stdio: ["ignore", "pipe", "inherit"],
-      });
-      const grep = Bun.spawn(["grep", "-i", channelFilter], {
-        stdio: [tail.stdout, "inherit", "inherit"],
-      });
-      await grep.exited;
-    } else {
-      const args = follow ? ["tail", "-f", daemonLog] : ["tail", "-50", daemonLog];
-      const proc = Bun.spawn(args, { stdio: ["ignore", "inherit", "inherit"] });
-      await proc.exited;
-    }
+    const { logsCommand } = await import("./logs");
+    await logsCommand(process.argv.slice(3));
     break;
   }
 
@@ -352,20 +242,8 @@ switch (command) {
   }
 
   case "skills": {
-    const { scanSkills: loadSkills } = await import("../core/skills");
-    const filter = process.argv[3]; // e.g. "project", "nia", "shared", "claude"
-    let skills = loadSkills();
-    if (filter) {
-      skills = skills.filter((s) => s.source === filter);
-    }
-    if (skills.length === 0) {
-      console.log(filter ? `No skills found in "${filter}".` : "No skills found.");
-    } else {
-      for (const s of skills) {
-        const tag = filter ? "" : `  [${s.source}]`;
-        console.log(`  ${s.name}${tag}`);
-      }
-    }
+    const { skillsCommand } = await import("./skills");
+    skillsCommand(process.argv[3]);
     break;
   }
 
@@ -390,90 +268,19 @@ switch (command) {
   }
 
   case "config": {
-    const configSub = process.argv[3];
-    const configKey = process.argv[4];
-    const configVal = process.argv.slice(5).join(" ");
-    const { readRawConfig, updateRawConfig } = await import("../utils/config");
-
-    if (configSub === "set" && configKey) {
-      if (!configVal) fail("Usage: nia config set <key> <value>");
-      // Support dot notation for nested keys (e.g. channels.default)
-      const parts = configKey.split(".");
-      let obj: Record<string, unknown> = {};
-      let cursor = obj;
-      for (let i = 0; i < parts.length - 1; i++) {
-        cursor[parts[i]] = {};
-        cursor = cursor[parts[i]] as Record<string, unknown>;
-      }
-      // Auto-detect booleans and numbers
-      let parsed: unknown = configVal;
-      if (configVal === "true") parsed = true;
-      else if (configVal === "false") parsed = false;
-      else if (/^\d+$/.test(configVal)) parsed = Number(configVal);
-      cursor[parts[parts.length - 1]] = parsed;
-      updateRawConfig(obj);
-      console.log(`${configKey} = ${configVal}`);
-    } else if (configSub === "get" && configKey) {
-      const raw = readRawConfig();
-      const parts = configKey.split(".");
-      let val: unknown = raw;
-      for (const p of parts) {
-        if (val && typeof val === "object") val = (val as Record<string, unknown>)[p];
-        else {
-          val = undefined;
-          break;
-        }
-      }
-      if (val === undefined) {
-        console.log(`${configKey}: (not set)`);
-      } else if (typeof val === "object") {
-        const yaml = (await import("js-yaml")).default;
-        console.log(yaml.dump(val, { lineWidth: -1 }).trim());
-      } else {
-        console.log(`${configKey} = ${val}`);
-      }
-    } else if (!configSub || configSub === "list") {
-      const raw = readRawConfig();
-      const yaml = (await import("js-yaml")).default;
-      console.log(yaml.dump(raw, { lineWidth: -1 }).trim());
-    } else {
-      console.log("Usage: nia config <set|get|list>");
-      console.log("  nia config set <key> <value>  — set a config value");
-      console.log("  nia config get <key>          — get a config value");
-      console.log("  nia config list               — show all config");
-    }
+    const { configCommand } = await import("./config");
+    await configCommand(process.argv[3], process.argv[4], process.argv.slice(5).join(" "));
     break;
   }
 
   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";
-      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(
-          target ? `${target} ${enabled ? "enabled" : "disabled"}` : `channels ${enabled ? "enabled" : "disabled"}`,
-        );
-      } else {
-        console.log(
-          target
-            ? `${target} ${enabled ? "enabled" : "disabled"} — start nia to apply`
-            : `channels ${enabled ? "enabled" : "disabled"} — start nia to apply`,
-        );
-      }
-    } else {
+    if (sub !== "on" && sub !== "off") {
       console.log(`channels: ${getConfig().channels.enabled ? "on" : "off"}`);
+      break;
     }
+    const { channelsToggleCommand } = await import("./update");
+    await channelsToggleCommand(sub, process.argv[4]);
     break;
   }
 
@@ -484,35 +291,8 @@ switch (command) {
   }
 
   case "test": {
-    const verbose = process.argv.includes("-v") || process.argv.includes("--verbose");
-    const extraArgs = process.argv.slice(3).filter((a) => a !== "-v" && a !== "--verbose");
-    const proc = Bun.spawn(["bun", "test", ...extraArgs], {
-      stdio: ["ignore", "pipe", "pipe"],
-      cwd: import.meta.dir + "/../..",
-      env: { ...process.env, LOG_LEVEL: "silent" },
-    });
-
-    const [stdout, stderr] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);
-    const exitCode = await proc.exited;
-    const output = stdout + stderr;
-
-    if (verbose) {
-      process.stdout.write(output);
-    } else {
-      for (const line of output.split("\n")) {
-        if (
-          /^\s*\d+ pass/.test(line) ||
-          /^\s*\d+ fail/.test(line) ||
-          /^Ran \d+ tests/.test(line) ||
-          /expect\(\) calls/.test(line)
-        ) {
-          console.log(line);
-        } else if (/^✗|FAIL|error:/i.test(line.trim())) {
-          console.log(line);
-        }
-      }
-    }
-    process.exit(exitCode);
+    const { testCommand } = await import("./test");
+    await testCommand(process.argv.slice(3));
   }
 
   case "backup": {
@@ -530,53 +310,8 @@ switch (command) {
   }
 
   case "update": {
-    const updateGuard = withDefaultWait(parseGuardFlags(process.argv.slice(3)), 1);
-    const { version: currentVersion } = await import("../../package.json");
-    console.log(`Current: v${currentVersion}`);
-
-    // Check active engines before doing anything destructive
-    if (isRunning() && !(await guardActiveEngines("update", updateGuard))) process.exit(1);
-
-    // Auto-backup before update
-    try {
-      const { createBackup } = await import("../commands/backup");
-      console.log("Backing up...");
-      await createBackup(true);
-      console.log("✓ pre-update backup created");
-    } catch (err) {
-      console.log(`⚠ backup skipped: ${errMsg(err)}`);
-    }
-    console.log("Updating...");
-    const install = Bun.spawn(["npm", "i", "-g", "niahere@latest"], {
-      stdio: ["ignore", "inherit", "inherit"],
-    });
-    const installExit = await install.exited;
-    if (installExit !== 0) {
-      fail("Update failed.");
-    }
-    // Get new version
-    const check = Bun.spawn(["npm", "view", "niahere", "version"], {
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-    const newVersion = (await new Response(check.stdout).text()).trim();
-    await check.exited;
-    if (newVersion === currentVersion) {
-      console.log("Already on latest.");
-    } else {
-      console.log(`Updated: v${currentVersion} → v${newVersion}`);
-      if (isRunning()) {
-        console.log("Restarting daemon...");
-        const { isServiceInstalled, restartService } = await import("../commands/service");
-        if (isServiceInstalled()) {
-          await restartService({ force: updateGuard.force });
-        } else {
-          stopDaemon({ force: updateGuard.force });
-          startDaemon();
-        }
-        console.log("Restarted.");
-      }
-    }
+    const { updateCommand } = await import("./update");
+    await updateCommand(process.argv.slice(3));
     break;
   }
 

package/src/cli/job.ts

@@ -1,4 +1,5 @@
 import * as readline from "readline";
+import { existsSync, readFileSync } from "fs";
 import { readState, readAudit } from "../utils/logger";
 import { getConfig } from "../utils/config";
 import { runJob } from "../core/runner";
@@ -145,7 +146,6 @@ export async function jobCommand(): Promise<void> {
       const promptFile = args.getString("prompt-file");
       let prompt: string;
       if (promptFile) {
-        const { existsSync, readFileSync } = await import("fs");
         if (!existsSync(promptFile)) fail(`File not found: ${promptFile}`);
         prompt = readFileSync(promptFile, "utf8").trim();
       } else if (promptFlag) {
@@ -243,7 +243,6 @@ export async function jobCommand(): Promise<void> {
       const promptFile = args.getString("prompt-file");
       let prompt = args.getString("prompt");
       if (promptFile) {
-        const { existsSync, readFileSync } = await import("fs");
         if (!existsSync(promptFile)) fail(`File not found: ${promptFile}`);
         prompt = readFileSync(promptFile, "utf8").trim();
       }

package/src/cli/logs.ts

@@ -0,0 +1,55 @@
+import { existsSync } from "fs";
+import { getPaths } from "../utils/paths";
+import { withDb } from "../db/with-db";
+import { Message } from "../db/models";
+import { localTime } from "../utils/time";
+import { errMsg } from "../utils/errors";
+
+const SNIPPET = 120;
+
+/** `nia history [room]` — recent messages, newest last. */
+export async function historyCommand(room?: string): Promise<void> {
+  try {
+    await withDb(async () => {
+      const messages = await Message.getRecent(20, room);
+      if (messages.length === 0) {
+        console.log("No messages yet.");
+        return;
+      }
+      for (const m of messages) {
+        const time = localTime(new Date(m.createdAt));
+        const prefix = m.sender === "user" ? "you" : m.sender;
+        const roomTag = room ? "" : `[${m.room}] `;
+        const snippet = m.content.length > SNIPPET ? m.content.slice(0, SNIPPET) + "..." : m.content;
+        console.log(`  ${roomTag}${time}  ${prefix} > ${snippet.replace(/\n/g, " ")}`);
+      }
+    });
+  } catch (err) {
+    console.error(`Failed: ${errMsg(err)}`);
+    process.exit(1);
+  }
+}
+
+/** `nia logs [-f] [--channel <name>]` — tail the daemon log. */
+export async function logsCommand(args: string[]): Promise<void> {
+  const { daemonLog } = getPaths();
+  if (!existsSync(daemonLog)) {
+    console.error("No daemon log found. Is nia running?");
+    process.exit(1);
+  }
+
+  const follow = args.includes("-f") || args.includes("--follow");
+  const chIdx = args.indexOf("--channel");
+  const channelFilter = chIdx !== -1 && args[chIdx + 1] ? args[chIdx + 1] : null;
+  const tailArgs = follow ? ["tail", "-f", daemonLog] : ["tail", channelFilter ? "-200" : "-50", daemonLog];
+
+  if (!channelFilter) {
+    const proc = Bun.spawn(tailArgs, { stdio: ["ignore", "inherit", "inherit"] });
+    await proc.exited;
+    return;
+  }
+
+  const tail = Bun.spawn(tailArgs, { stdio: ["ignore", "pipe", "inherit"] });
+  const grep = Bun.spawn(["grep", "-i", channelFilter], { stdio: [tail.stdout, "inherit", "inherit"] });
+  await grep.exited;
+}

package/src/cli/run.ts

@@ -0,0 +1,74 @@
+import { withDb } from "../db/with-db";
+
+/** `nia run <prompt>` — one-shot terminal turn with a spinner and streamed output. */
+export async function runPrompt(prompt: string): Promise<void> {
+  const { createChatEngine } = await import("../chat/engine");
+  const { getMcpServers } = await import("../mcp");
+  const { DIM, RESET, CLEAR_LINE, SPINNER } = await import("../utils/cli");
+
+  let frame = 0;
+  let statusText = "thinking";
+  let spinTimer: ReturnType<typeof setInterval> | null = null;
+  let streamedLen = 0;
+  let streaming = false;
+
+  const renderSpinner = () => {
+    process.stderr.write(`${CLEAR_LINE}${DIM}  ${SPINNER[frame]} ${statusText}${RESET}`);
+    frame = (frame + 1) % SPINNER.length;
+  };
+  const stopSpinner = () => {
+    if (spinTimer) {
+      clearInterval(spinTimer);
+      spinTimer = null;
+    }
+  };
+
+  await withDb(async () => {
+    const engine = await createChatEngine({
+      room: "cli-run",
+      channel: "terminal",
+      resume: false,
+      mcpServers: getMcpServers(),
+    });
+    spinTimer = setInterval(renderSpinner, 80);
+    renderSpinner();
+
+    const { result, costUsd, turns } = await engine.send(prompt, {
+      onStream(textSoFar) {
+        if (!streaming) {
+          stopSpinner();
+          process.stderr.write("\x1b[2K\r");
+          streaming = true;
+        }
+        const chunk = textSoFar.slice(streamedLen);
+        if (chunk) {
+          process.stdout.write(chunk);
+          streamedLen = textSoFar.length;
+        }
+      },
+      onActivity(text) {
+        if (!streaming) statusText = text;
+      },
+    });
+
+    stopSpinner();
+
+    if (!streaming && result.trim()) {
+      process.stderr.write("\x1b[2K\r");
+      process.stdout.write(result.trim());
+    } else if (streaming) {
+      const rest = result.slice(streamedLen);
+      if (rest.trim()) process.stdout.write(rest);
+    } else {
+      process.stderr.write("\x1b[2K\r");
+    }
+
+    const costStr = costUsd > 0 ? `$${costUsd.toFixed(4)}` : "";
+    const turnsStr = turns > 0 ? `${turns} turn${turns !== 1 ? "s" : ""}` : "";
+    const meta = [costStr, turnsStr].filter(Boolean).join(" · ");
+    if (meta) process.stderr.write(`\n${DIM}${meta}${RESET}`);
+    process.stdout.write("\n");
+
+    await engine.close();
+  });
+}

package/src/cli/skills.ts

@@ -0,0 +1,13 @@
+import { scanSkills } from "../core/skills";
+
+/** `nia skills [source]` — list discovered skills, optionally filtered by source. */
+export function skillsCommand(filter?: string): void {
+  const skills = filter ? scanSkills().filter((s) => s.source === filter) : scanSkills();
+  if (skills.length === 0) {
+    console.log(filter ? `No skills found in "${filter}".` : "No skills found.");
+    return;
+  }
+  for (const s of skills) {
+    console.log(`  ${s.name}${filter ? "" : `  [${s.source}]`}`);
+  }
+}

package/src/cli/status.ts

@@ -1,7 +1,6 @@
 import { isRunning, readPid } from "../core/daemon";
 import { readState } from "../utils/logger";
 import { getConfig } from "../utils/config";
-import { localTime } from "../utils/time";
 import { maskToken, safeDate, dateSortValue, formatTimeLine } from "../utils/format";
 import { Message, ActiveEngine, Job } from "../db/models";
 import type { ScheduleType, JobStateStatus, RoomStats } from "../types";

package/src/cli/test.ts

@@ -0,0 +1,32 @@
+/** `nia test` — run the suite, showing only the summary unless -v. */
+
+const SUMMARY = [/^\s*\d+ pass/, /^\s*\d+ fail/, /^Ran \d+ tests/, /expect\(\) calls/];
+const FAILURE = /^✗|FAIL|error:/i;
+
+function isWorthShowing(line: string): boolean {
+  return SUMMARY.some((p) => p.test(line)) || FAILURE.test(line.trim());
+}
+
+export async function testCommand(argv: string[]): Promise<never> {
+  const verbose = argv.includes("-v") || argv.includes("--verbose");
+  const extraArgs = argv.filter((a) => a !== "-v" && a !== "--verbose");
+
+  const proc = Bun.spawn(["bun", "test", ...extraArgs], {
+    stdio: ["ignore", "pipe", "pipe"],
+    cwd: import.meta.dir + "/../..",
+    env: { ...process.env, LOG_LEVEL: "silent" },
+  });
+
+  const [stdout, stderr] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);
+  const exitCode = await proc.exited;
+  const output = stdout + stderr;
+
+  if (verbose) {
+    process.stdout.write(output);
+  } else {
+    for (const line of output.split("\n")) {
+      if (isWorthShowing(line)) console.log(line);
+    }
+  }
+  process.exit(exitCode);
+}

package/src/cli/update.ts

@@ -0,0 +1,79 @@
+import { isRunning, readPid } from "../utils/pid";
+import { errMsg } from "../utils/errors";
+import { guardActiveEngines, parseGuardFlags, withDefaultWait } from "../core/engine-guard";
+import { startDaemon, stopDaemon } from "../core/daemon";
+
+/** `nia update` — upgrade the global install, then restart if the daemon is up. */
+export async function updateCommand(argv: string[]): Promise<void> {
+  const guard = withDefaultWait(parseGuardFlags(argv), 1);
+  const { version: currentVersion } = await import("../../package.json");
+  console.log(`Current: v${currentVersion}`);
+
+  // Never upgrade out from under a live turn.
+  if (isRunning() && !(await guardActiveEngines("update", guard))) process.exit(1);
+
+  try {
+    const { createBackup } = await import("../commands/backup");
+    console.log("Backing up...");
+    await createBackup(true);
+    console.log("✓ pre-update backup created");
+  } catch (err) {
+    console.log(`⚠ backup skipped: ${errMsg(err)}`);
+  }
+
+  console.log("Updating...");
+  const install = Bun.spawn(["npm", "i", "-g", "niahere@latest"], { stdio: ["ignore", "inherit", "inherit"] });
+  if ((await install.exited) !== 0) {
+    console.error("Update failed.");
+    process.exit(1);
+  }
+
+  const check = Bun.spawn(["npm", "view", "niahere", "version"], { stdout: "pipe", stderr: "pipe" });
+  const newVersion = (await new Response(check.stdout).text()).trim();
+  await check.exited;
+
+  if (newVersion === currentVersion) {
+    console.log("Already on latest.");
+    return;
+  }
+
+  console.log(`Updated: v${currentVersion} → v${newVersion}`);
+  if (!isRunning()) return;
+
+  console.log("Restarting daemon...");
+  const { isServiceInstalled, restartService } = await import("../commands/service");
+  if (isServiceInstalled()) {
+    await restartService({ force: guard.force });
+  } else {
+    stopDaemon({ force: guard.force });
+    startDaemon();
+  }
+  console.log("Restarted.");
+}
+
+/** `nia channels <on|off> [name]` — toggle channels and nudge a running daemon. */
+export async function channelsToggleCommand(sub: string, target?: string): Promise<void> {
+  const { updateRawConfig } = await import("../utils/config");
+  const SUPPORTED = new Set(["telegram", "slack", "phone", "sms", "whatsapp"]);
+  const enabled = sub === "on";
+
+  if (target) {
+    if (!SUPPORTED.has(target)) {
+      console.error(`Usage: nia channels <on|off> [${[...SUPPORTED].join("|")}]`);
+      process.exit(1);
+    }
+    updateRawConfig({ channels: { ...(enabled ? { enabled: true } : {}), [target]: { enabled } } });
+  } else {
+    updateRawConfig({ channels: { enabled } });
+  }
+
+  const what = target ?? "channels";
+  const state = enabled ? "enabled" : "disabled";
+  const pid = readPid();
+  if (pid && isRunning()) {
+    process.kill(pid, "SIGHUP");
+    console.log(`${what} ${state}`);
+  } else {
+    console.log(`${what} ${state} — start nia to apply`);
+  }
+}