nemoris 0.1.0

package/src/onboarding/toml-writer.js

@@ -0,0 +1,38 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parse } from "smol-toml";
+
+export function upsertTomlSection(content, sectionName, newBlock) {
+  const escaped = sectionName.replace(/\./g, "\\.");
+  const sectionRegex = new RegExp(`\\n?\\[${escaped}\\][\\s\\S]*?(?=\\n\\[|$)`, "g");
+  const stripped = String(content || "").replace(sectionRegex, "").trimEnd();
+  const block = String(newBlock || "").trim();
+  return stripped ? `${stripped}\n\n${block}\n` : `${block}\n`;
+}
+
+export function countTomlSections(content, sectionName) {
+  const escaped = sectionName.replace(/\./g, "\\.");
+  const sectionRegex = new RegExp(`\\[${escaped}\\]`, "g");
+  return (String(content || "").match(sectionRegex) || []).length;
+}
+
+export function assertSingleTomlSection(content, sectionName) {
+  if (countTomlSections(content, sectionName) > 1) {
+    throw new Error(`Invalid TOML document: duplicate [${sectionName}] section.`);
+  }
+  parse(String(content || ""));
+}
+
+export function writeTomlSection(filePath, sectionName, newBlock) {
+  let content = "";
+  try {
+    content = fs.readFileSync(filePath, "utf8");
+  } catch {
+    content = "";
+  }
+  const next = upsertTomlSection(content, sectionName, newBlock);
+  assertSingleTomlSection(next, sectionName);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, next, "utf8");
+  return next;
+}

package/src/onboarding/tui.js

@@ -0,0 +1,250 @@
+import readline from "node:readline";
+
+// ── ANSI (Node 25 util.styleText or fallback) ───────────────────
+const hasStyleText = typeof (await import("node:util")).styleText === "function";
+const { styleText } = hasStyleText ? await import("node:util") : {};
+
+export function bold(text) {
+  return hasStyleText ? styleText("bold", text) : `\x1b[1m${text}\x1b[0m`;
+}
+export function green(text) {
+  return hasStyleText ? styleText("green", text) : `\x1b[32m${text}\x1b[0m`;
+}
+export function red(text) {
+  return hasStyleText ? styleText("red", text) : `\x1b[31m${text}\x1b[0m`;
+}
+export function yellow(text) {
+  return hasStyleText ? styleText("yellow", text) : `\x1b[33m${text}\x1b[0m`;
+}
+export function dim(text) {
+  return hasStyleText ? styleText("dim", text) : `\x1b[2m${text}\x1b[0m`;
+}
+
+// ── Formatting ──────────────────────────────────────────────────
+
+export function maskKey(key) {
+  if (!key || key.length < 8) return "***";
+  return key.slice(0, 6) + "..." + key.slice(-3);
+}
+
+export function formatCheck(label, value, status) {
+  const icon = status === "pass" ? green("✓")
+    : status === "fail" ? red("✗")
+    : yellow("!");
+  return `  ${label.padEnd(15)}${value.padEnd(20)}${icon}`;
+}
+
+export function formatSection(title) {
+  return `\n  ${bold(title)}`;
+}
+
+// Brand accent: #2dd4bf — matches nanoclawV2 --color-accent
+const BRAND = "\x1b[38;2;45;212;191m";
+const RESET = "\x1b[0m";
+const brand = (s) => `${BRAND}${s}${RESET}`;
+
+export function banner(title, version) {
+  const ascii = [
+    "███╗   ██╗███████╗███╗   ███╗ ██████╗ ██████╗ ██╗███████╗",
+    "████╗  ██║██╔════╝████╗ ████║██╔═══██╗██╔══██╗██║██╔════╝",
+    "██╔██╗ ██║█████╗  ██╔████╔██║██║   ██║██████╔╝██║███████╗",
+    "██║╚██╗██║██╔══╝  ██║╚██╔╝██║██║   ██║██╔══██╗██║╚════██║",
+    "██║ ╚████║███████╗██║ ╚═╝ ██║╚██████╔╝██║  ██║██║███████║",
+    "╚═╝  ╚═══╝╚══════╝╚═╝     ╚═╝ ╚═════╝ ╚═╝  ╚═╝╚═╝╚══════╝",
+  ].join("\n");
+  // Font: ANSI Shadow — https://patorjk.com/software/taag/#p=display&f=ANSI+Shadow&t=Nemoris
+  return `\n${brand(ascii)}\n${dim(`  v${version}`)}\n`;
+}
+
+// ── Input ───────────────────────────────────────────────────────
+
+export function prompt(question, defaultValue) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const suffix = defaultValue ? dim(` (${defaultValue})`) : "";
+    rl.question(`  ${question}${suffix}: `, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue || "");
+    });
+  });
+}
+
+export function promptSecret(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    process.stdout.write(`  ${question}: `);
+    // Mute output for secret input
+    const originalWrite = process.stdout.write.bind(process.stdout);
+    let collecting = true;
+    process.stdout.write = (chunk) => {
+      if (collecting && typeof chunk === "string" && !chunk.includes(question)) return true;
+      return originalWrite(chunk);
+    };
+    rl.question("", (answer) => {
+      collecting = false;
+      process.stdout.write = originalWrite;
+      process.stdout.write("\n");
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+export function confirm(question, defaultValue = true) {
+  if (!process.stdin.isTTY || !process.stdin.setRawMode) {
+    return new Promise((resolve) => {
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const hint = defaultValue ? "Y/n" : "y/N";
+      rl.question(`  ${question} ${dim(`(${hint})`)}: `, (answer) => {
+        rl.close();
+        const a = answer.trim().toLowerCase();
+        resolve(a === "" ? defaultValue : a === "y");
+      });
+    });
+  }
+  return new Promise((resolve) => {
+    let yes = defaultValue;
+    function draw(first) {
+      const yLabel = yes ? bold(cyan("Yes")) : dim("Yes");
+      const nLabel = !yes ? bold(cyan("No")) : dim("No");
+      if (!first) process.stdout.write("\x1B[1A\x1B[2K");
+      process.stdout.write(`  ${question}  ${yLabel}  ${nLabel}\n`);
+    }
+    draw(true);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    function onKey(key) {
+      if (key === "\x1B[D" || key === "\x1B[A" || key === "h" || key === "k") {
+        yes = true;
+        draw(false);
+      } else if (key === "\x1B[C" || key === "\x1B[B" || key === "l" || key === "j") {
+        yes = false;
+        draw(false);
+      } else if (key === "\r" || key === "\n") {
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdin.removeListener("data", onKey);
+        resolve(yes);
+      } else if (key === "\x03") {
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.exit(1);
+      }
+    }
+    process.stdin.on("data", onKey);
+  });
+}
+
+function countRenderedOptionLines(option) {
+  const description = option.description || option.desc || "";
+  return 1 + String(description).split("\n").filter(Boolean).length;
+}
+
+function renderOption(option, index, selected) {
+  const marker = selected ? cyan("›") : " ";
+  const label = selected ? bold(option.label) : dim(option.label);
+  console.log(`    ${marker} ${label}`);
+
+  const description = option.description || option.desc || "";
+  for (const line of String(description).split("\n").filter(Boolean)) {
+    console.log(`      ${dim(line)}`);
+  }
+}
+
+export function select(question, options) {
+  if (!process.stdin.isTTY || !process.stdin.setRawMode) {
+    return new Promise((resolve) => {
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      console.log(`\n  ${question}`);
+      options.forEach((opt, i) => {
+        console.log(`    ${dim(`[${i + 1}]`)} ${opt.label}`);
+        const description = opt.description || opt.desc || "";
+        for (const line of String(description).split("\n").filter(Boolean)) {
+          console.log(`      ${dim(line)}`);
+        }
+      });
+      rl.question(`\n  Choice: `, (answer) => {
+        rl.close();
+        const idx = parseInt(answer, 10) - 1;
+        resolve(options[idx >= 0 && idx < options.length ? idx : 0].value);
+      });
+    });
+  }
+  return new Promise((resolve) => {
+    let selected = 0;
+    const renderedLines = 1 + options.reduce((sum, opt) => sum + countRenderedOptionLines(opt), 0);
+    function render(first) {
+      if (!first) process.stdout.write(`\x1B[${renderedLines}A\x1B[J`);
+      console.log(`  ${question}`);
+      options.forEach((opt, i) => renderOption(opt, i, i === selected));
+    }
+    console.log("");
+    render(true);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    function onKey(key) {
+      if (key === "\x1B[A" || key === "k") {
+        selected = Math.max(0, selected - 1);
+        render(false);
+      } else if (key === "\x1B[B" || key === "j") {
+        selected = Math.min(options.length - 1, selected + 1);
+        render(false);
+      } else if (key === "\r" || key === "\n") {
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdin.removeListener("data", onKey);
+        process.stdout.write("\n");
+        resolve(options[selected].value);
+      } else if (key === "\x03") {
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.exit(1);
+      }
+    }
+    process.stdin.on("data", onKey);
+  });
+}
+
+export function waitForEnter(message) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(`  ${message} `, () => {
+      rl.close();
+      resolve();
+    });
+  });
+}
+
+// ── Nemoris-branded rendering helpers ───────────────────────────
+// Match the landing page terminal style: teal accent, tree connectors
+
+export function cyan(text) {
+  // Always use raw ANSI for cyan: styleText strips codes in non-TTY environments
+  // which breaks test assertions and terminal output in piped contexts.
+  return `\x1b[36m${text}\x1b[0m`;
+}
+
+export function treeItem(label, value, status) {
+  const icon = status === "pass" ? green("✓ ")
+    : status === "fail" ? red("✗ ")
+    : "";
+  return `  ${dim("└")} ${icon}${dim(label.padEnd(12))}${cyan(value)}`;
+}
+
+export function progressLine(label, filePath) {
+  return `  ${green("✓")} ${label.padEnd(24)}${dim(filePath)}`;
+}
+
+export function sectionHeader(text) {
+  return `  ${bold("•")} ${text}`;
+}
+
+export function whatsNext(commands) {
+  const lines = [`\n  ${bold("What's next:")}\n`];
+  for (const [cmd, desc] of commands) {
+    lines.push(`    ${cyan(cmd.padEnd(22))}${dim(desc)}`);
+  }
+  return lines.join("\n") + "\n";
+}

package/src/onboarding/uninstall.js

@@ -0,0 +1,153 @@
+/**
+ * nemoris uninstall
+ *
+ * Removes all user-specific setup artifacts:
+ *   - Daemon plist (ai.nemoris.daemon.plist + legacy ai.nanoclaw.daemon.plist)
+ *   - .env (secrets)
+ *   - state/ (SQLite DB + runtime state)
+ *   - config/runtime.toml (reset to git default via git checkout, or delete if not in git)
+ *
+ * The code repo itself is NOT removed — you keep the install directory.
+ * Re-run `nemoris setup` to start fresh.
+ */
+
+import { execFile as execFileCb } from "node:child_process";
+import { promisify } from "node:util";
+import { existsSync, rmSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { unloadDaemon } from "./platform.js";
+import { getDaemonPaths, readTrackedPid, isPidRunning } from "../cli/runtime-control.js";
+
+const execFile = promisify(execFileCb);
+
+async function confirm(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+
+async function wipeEnv(installDir) {
+  const envPath = join(installDir, ".env");
+  if (existsSync(envPath)) {
+    // Grab bot token before wiping so we can print it for safekeeping
+    let botToken = null;
+    try {
+      const lines = readFileSync(envPath, "utf8").split("\n");
+      for (const line of lines) {
+        const m = line.match(/^NEMORIS_TELEGRAM_BOT_TOKEN\s*=\s*(.+)/);
+        if (m) botToken = m[1].trim();
+      }
+    } catch (_) {}
+
+    rmSync(envPath);
+    console.log("  ✓ .env removed");
+    if (botToken) {
+      console.log(`  ℹ Bot token for reference: ${botToken}`);
+    }
+  } else {
+    console.log("  · .env not found (already clean)");
+  }
+}
+
+/**
+ * Kill any foreground daemon tracked by daemon.pid before wiping state.
+ * unloadDaemon() handles PM2/launchctl/systemd — this covers the
+ * `nemoris start --foreground` case which only leaves a PID file.
+ * Safe no-op if no process is running.
+ */
+async function stopForegroundDaemon(installDir) {
+  const { pidFile, lockFile } = getDaemonPaths(installDir);
+  const pid = readTrackedPid(pidFile);
+
+  if (!pid || !isPidRunning(pid)) return;
+
+  console.log(`  · Stopping foreground daemon (pid ${pid})...`);
+
+  // Send SIGTERM (graceful on Linux/macOS; TerminateProcess on Windows — immediate)
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch (e) {
+    if (e.code !== "ESRCH" && e.code !== "EPERM") throw e;
+  }
+
+  // Wait up to 3 s for the process to exit (no-op on Windows — already gone)
+  for (let i = 0; i < 6; i++) {
+    await new Promise((r) => setTimeout(r, 500));
+    if (!isPidRunning(pid)) break;
+  }
+
+  // Force-kill if still alive (Linux/macOS only — won't reach here on Windows)
+  if (isPidRunning(pid)) {
+    try { process.kill(pid, "SIGKILL"); } catch (_) {}
+    await new Promise((r) => setTimeout(r, 500));
+  }
+
+  // Clean up stale PID / lock files so wipeState() has no contention
+  for (const f of [pidFile, lockFile]) {
+    try { rmSync(f, { force: true }); } catch (_) {}
+  }
+
+  console.log("  ✓ Foreground daemon stopped");
+}
+
+async function wipeState(installDir) {
+  const statePath = join(installDir, "state");
+  if (existsSync(statePath)) {
+    rmSync(statePath, { recursive: true, force: true });
+    console.log("  ✓ state/ removed");
+  } else {
+    console.log("  · state/ not found (already clean)");
+  }
+}
+
+async function resetRuntimeToml(installDir) {
+  const runtimeToml = join(installDir, "config", "runtime.toml");
+  if (!existsSync(runtimeToml)) {
+    console.log("  · config/runtime.toml not found (already clean)");
+    return;
+  }
+  try {
+    // Try git reset first (preserves git-tracked default)
+    await execFile("git", ["checkout", "config/runtime.toml"], { cwd: installDir, timeout: 5000 });
+    console.log("  ✓ config/runtime.toml reset to git default");
+  } catch (_) {
+    // Not a git repo or file not in git — just remove it
+    rmSync(runtimeToml, { force: true });
+    console.log("  ✓ config/runtime.toml removed");
+  }
+}
+
+export async function runUninstall({ installDir = process.cwd(), force = false } = {}) {
+  console.log("\n🗑  Nemoris Uninstall\n");
+  console.log("This will remove:");
+  console.log("  • Daemon service (stops the background service)");
+  console.log("  • .env (secrets — save your bot token first if needed)");
+  console.log("  • state/ (all sessions, jobs, and history)");
+  console.log("  • config/runtime.toml (reset to defaults)");
+  console.log("\nThe Nemoris binary is not removed. Run `nemoris setup` to start fresh.\n");
+
+  if (!force) {
+    const answer = await confirm("Are you sure? Type 'yes' to continue: ");
+    if (answer !== "yes") {
+      console.log("\nAborted. Nothing changed.\n");
+      return 0;
+    }
+  }
+
+  console.log("\nUninstalling...\n");
+
+  await unloadDaemon();
+  await stopForegroundDaemon(installDir);
+  await wipeEnv(installDir);
+  await wipeState(installDir);
+  await resetRuntimeToml(installDir);
+
+  console.log("\n✅ Nemoris uninstalled cleanly.");
+  console.log("   Run `nemoris setup` to configure and start again.\n");
+  return 0;
+}