nemoris 0.1.0

package/src/onboarding/phases/verify.js

@@ -0,0 +1,206 @@
+import fs from "node:fs";
+import path from "node:path";
+import { validateScaffold } from "./validate.js";
+import { sendHatchMessage } from "./telegram.js";
+import { writeDaemonUnit, loadDaemon } from "../platform.js";
+import { green, yellow, dim, cyan, treeItem, sectionHeader, confirm, bold } from "../tui.js";
+
+export function getCommandsWorthKnowing({ telegramConfigured = false } = {}) {
+  const commands = [
+    ["nemoris status", "see what your agent is doing"],
+    ["nemoris doctor", "run a health check"],
+    ["nemoris logs", "watch live daemon output"],
+  ];
+  if (telegramConfigured) {
+    commands.push(["/help", "show commands in Telegram"]);
+  }
+  return commands;
+}
+
+/**
+ * Verify phase — dry-run health check + "what's next" output.
+ * Replaces the old hatch phase egg animation.
+ *
+ * In non-interactive mode, returns JSON summary.
+ */
+export async function verify({
+  installDir,
+  agentName,
+  userName,
+  agentId,
+  mode,
+  providers = [],
+  providerFlags: _providerFlags = {},
+  nonInteractive = false,
+  skipHealthcheck = false,
+  importStats = null,
+  telegramConfigured = false,
+  telegramVerified = false,
+  telegramBotUsername = null,
+  telegramBotToken = null,
+  telegramOperatorChatId = null,
+  userGoal = "",
+}) {
+  const result = {
+    status: "ok",
+    mode,
+    agent: agentId,
+    provider: providers[0] || "none",
+    ...(mode === "shadow" && importStats ? { imported: importStats } : {}),
+    healthcheck: "skip",
+  };
+
+  // Run validation / health check
+  if (!skipHealthcheck) {
+    try {
+      const validation = await validateScaffold(installDir);
+      result.healthcheck = validation.configValid ? "pass" : "fail";
+      if (!validation.configValid) {
+        result.status = "warning";
+        result.errors = validation.errors;
+      }
+    } catch {
+      result.healthcheck = "fail";
+    }
+  }
+
+  // Non-interactive: return JSON
+  if (nonInteractive) {
+    if (!process.env.NEMORIS_QUIET) {
+      console.log(JSON.stringify(result));
+    }
+    return result;
+  }
+
+  // Interactive: structured output
+  console.log(`\n${sectionHeader("First Run (dry)")}`);
+  console.log(treeItem("provider", providers[0] || "none"));
+  if (mode === "shadow" && importStats) {
+    console.log(treeItem("memory", `${importStats.memory} entries loaded`));
+  } else {
+    console.log(treeItem("memory", "empty · first run"));
+  }
+  console.log(treeItem("contract", "HealthCheck"));
+
+  if (result.healthcheck === "pass") {
+    const suffix = mode === "shadow" ? `${agentName} is home` : "your agent is alive";
+    console.log(`  ${green("✓")} healthy — ${suffix}`);
+  } else if (result.healthcheck === "skip") {
+    console.log(`  ${dim("⊘")} health check skipped`);
+  } else {
+    console.log(`  ${dim("!")} health check had issues (run nemoris doctor)`);
+  }
+
+  // Telegram status
+  if (telegramConfigured && telegramVerified) {
+    console.log(treeItem("telegram", `connected · @${telegramBotUsername || "bot"}`, "pass"));
+  } else if (telegramConfigured && !telegramVerified) {
+    console.log(`  ${yellow("!")} Telegram configured but not verified — run ${cyan("nemoris setup telegram")} to test`);
+  }
+
+  console.log(`\n  ${green("✓")} Nemoris is ready`);
+
+  // Auto-start daemon
+  let daemonStarted = false;
+  let hatchSent = false;
+  let unitWritten = false;
+
+  try {
+    const unitResult = await writeDaemonUnit(installDir);
+    unitWritten = unitResult.ok;
+  } catch (err) {
+    console.log(`  ${yellow("!")} Couldn't write daemon unit: ${err.message}`);
+  }
+
+  if (unitWritten) {
+    const start = await confirm("Start your agent now?", true);
+    if (start) {
+      const loadResult = await loadDaemon(installDir);
+      if (loadResult.ok) {
+        daemonStarted = true;
+
+        // Send hatch message to Telegram
+        if (telegramConfigured && telegramVerified && telegramOperatorChatId && telegramBotToken) {
+          try {
+            // Load identity content + provider config for AI-generated greeting
+            let soulContent = "";
+            let purposeContent = "";
+            let providerConfig = null;
+
+            try {
+              const effectiveId = agentId || agentName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+              const identityDir = path.join(installDir, "config", "identity");
+              soulContent = fs.readFileSync(path.join(identityDir, `${effectiveId}-soul.md`), "utf8");
+              purposeContent = fs.readFileSync(path.join(identityDir, `${effectiveId}-purpose.md`), "utf8");
+            } catch {
+              // Identity files may not exist yet — use defaults
+            }
+
+            if (providers.length > 0) {
+              try {
+                const { ConfigLoader } = await import("../../config/loader.js");
+                const loader = new ConfigLoader({ rootDir: path.join(installDir, "config") });
+                const providerMap = await loader.loadProviders();
+                providerConfig = providerMap[providers[0]] || null;
+              } catch {
+                // Provider config may not be loadable — fall back to static greeting
+              }
+            }
+
+            // Detect migrated vs fresh: shadow mode or existing memory = migrated agent
+            const isMigrated = mode === "shadow" || (importStats && importStats.memory > 0);
+
+            const hatched = await sendHatchMessage({
+              token: telegramBotToken,
+              chatId: telegramOperatorChatId,
+              agentName,
+              userName,
+              installDir,
+              agentId,
+              userGoal,
+              soulContent,
+              purposeContent,
+              providerConfig,
+              migrated: isMigrated,
+            });
+            if (hatched) {
+              hatchSent = true;
+            }
+          } catch {
+            // best-effort, don't fail setup if this errors
+          }
+        }
+      } else {
+        console.log(`  ${yellow("!")} ${loadResult.message || "Couldn't auto-start"} — run ${cyan("nemoris start")} manually`);
+      }
+    }
+  }
+
+  // Final Output
+  console.log(`\n  ${dim("──────────────────────────────────────────────")}`);
+  console.log(`  ${bold("Your agent is live.")}\n`);
+
+  if (daemonStarted) {
+    console.log(`  ${green("✓")} Daemon running in the background`);
+  } else {
+    console.log(`  ${yellow("!")} Run ${cyan("nemoris start")} to bring your agent online`);
+  }
+
+  if (hatchSent && telegramBotUsername) {
+    console.log(`  ${green("✓")} First message sent to @${telegramBotUsername} — check your phone`);
+  }
+
+  if (daemonStarted) {
+    console.log(`\n  When you're done here, your agent is waiting in Telegram.`);
+  }
+  console.log(`  ${dim("──────────────────────────────────────────────")}`);
+
+  console.log(`\n  ${bold("Commands worth knowing:")}`);
+  for (const [command, description] of getCommandsWorthKnowing({ telegramConfigured })) {
+    console.log(`  ${command.padEnd(19)} ${description}`);
+  }
+
+  console.log(`\n  ${dim("docs: https://github.com/amzer24/nemoris#readme")}\n`);
+
+  return result;
+}

package/src/onboarding/platform.js

@@ -0,0 +1,482 @@
+/**
+ * platform.js — Cross-platform daemon management adapter.
+ *
+ * All platform-specific daemon operations (macOS launchctl, Linux systemd,
+ * Windows PM2) live here. Callers import these functions instead of
+ * scattering launchctl/systemd/pm2 code across the codebase.
+ */
+
+import { execFile as execFileCb, spawnSync } from "node:child_process";
+import { promisify } from "node:util";
+import { existsSync, rmSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import fs from "node:fs/promises";
+import { join } from "node:path";
+import os from "node:os";
+
+const execFile = promisify(execFileCb);
+
+// ── Constants ────────────────────────────────────────────────────
+
+const PLIST_NAMES = ["ai.nemoris.daemon.plist", "ai.nanoclaw.daemon.plist"];
+const SYSTEMD_UNIT = "nemoris.service";
+export const DAEMON_OUT_LOG = "daemon.out.log";
+export const DAEMON_ERR_LOG = "daemon.err.log";
+export const DAEMON_PID_FILE = "daemon.pid";
+
+function getHomeDir() {
+  return process.env.HOME || os.homedir();
+}
+
+function getLaunchAgentsDir() {
+  return join(getHomeDir(), "Library", "LaunchAgents");
+}
+
+function getSystemdUserDir() {
+  return join(getHomeDir(), ".config", "systemd", "user");
+}
+
+function getDaemonEnvDir() {
+  return join(getHomeDir(), ".config", "nemoris");
+}
+
+function getDaemonEnvFile() {
+  return join(getDaemonEnvDir(), "daemon.env");
+}
+
+// ── detectPlatform ───────────────────────────────────────────────
+
+export function detectPlatform() {
+  const platform = process.platform;
+  const arch = process.arch;
+  const nodeVersion = process.version;
+  const major = parseInt(nodeVersion.replace(/^v/, ""), 10);
+  const nodeOk = major >= 22;
+
+  let hasPm2 = false;
+  try {
+    const r = spawnSync("pm2", ["--version"], { timeout: 3000, stdio: "pipe" });
+    hasPm2 = r.status === 0;
+  } catch { /* noop */ }
+
+  let hasSystemctl = false;
+  if (platform === "linux") {
+    try {
+      const r = spawnSync("systemctl", ["--user", "--version"], { timeout: 3000, stdio: "pipe" });
+      hasSystemctl = r.status === 0;
+    } catch { /* noop */ }
+  }
+
+  return {
+    os: platform,
+    arch,
+    nodeVersion,
+    nodeOk,
+    hasPm2,
+    hasSystemctl,
+  };
+}
+
+// ── writeDaemonUnit ──────────────────────────────────────────────
+
+export async function writeDaemonUnit(installDir) {
+  const platform = process.platform;
+
+  if (platform === "darwin") {
+    return writeMacOsPlist(installDir);
+  }
+
+  if (platform === "linux") {
+    return writeSystemdUnit(installDir);
+  }
+
+  // Windows / other — no unit file to write
+  return { ok: true, path: null, message: "No daemon unit needed on this platform." };
+}
+
+async function writeMacOsPlist(installDir) {
+  const plistDir = getLaunchAgentsDir();
+  const plistPath = join(plistDir, "ai.nemoris.daemon.plist");
+
+  const { stdout: whichOut } = await execFile("which", ["nemoris"]).catch(() => ({ stdout: "" }));
+  const nemorisBin = whichOut.trim() || join(installDir, "src", "cli.js");
+
+  const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>ai.nemoris.daemon</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nemorisBin}</string>
+    <string>serve-daemon</string>
+    <string>live</string>
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${installDir}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${installDir}/state/${DAEMON_OUT_LOG}</string>
+  <key>StandardErrorPath</key>
+  <string>${installDir}/state/${DAEMON_ERR_LOG}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>NEMORIS_INSTALL_DIR</key>
+    <string>${installDir}</string>
+  </dict>
+</dict>
+</plist>`;
+
+  await fs.mkdir(plistDir, { recursive: true });
+  await fs.writeFile(plistPath, plistContent, "utf8");
+  return { ok: true, path: plistPath };
+}
+
+async function writeSystemdUnit(installDir) {
+  const { stdout: whichOut } = await execFile("which", ["nemoris"]).catch(() => ({ stdout: "" }));
+  const nemorisBin = whichOut.trim() || join(installDir, "src", "cli.js");
+
+  const unitContent = `[Unit]
+Description=Nemoris Agent Runtime
+After=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${nemorisBin} serve-daemon live
+WorkingDirectory=${installDir}
+Restart=on-failure
+RestartSec=10
+EnvironmentFile=-${getDaemonEnvFile()}
+Environment=NEMORIS_INSTALL_DIR=${installDir}
+StandardOutput=append:${installDir}/state/${DAEMON_OUT_LOG}
+StandardError=append:${installDir}/state/${DAEMON_ERR_LOG}
+
+[Install]
+WantedBy=default.target
+`;
+
+  const systemdUserDir = getSystemdUserDir();
+  await fs.mkdir(systemdUserDir, { recursive: true });
+  const unitPath = join(systemdUserDir, SYSTEMD_UNIT);
+  await fs.writeFile(unitPath, unitContent, "utf8");
+  return { ok: true, path: unitPath };
+}
+
+// ── loadDaemon ───────────────────────────────────────────────────
+
+export function hasDaemonServiceUnit({ platform = process.platform, existsImpl = existsSync } = {}) {
+  if (platform === "darwin") {
+    return PLIST_NAMES.some((name) => existsImpl(join(getLaunchAgentsDir(), name)));
+  }
+
+  if (platform === "linux") {
+    return existsImpl(join(getSystemdUserDir(), SYSTEMD_UNIT));
+  }
+
+  return false;
+}
+
+export async function loadDaemon(installDir, { platform = process.platform, execFileImpl = execFile, existsImpl = existsSync } = {}) {
+  
+  if (platform === "darwin") {
+    const plistPath = join(getLaunchAgentsDir(), "ai.nemoris.daemon.plist");
+    if (!existsImpl(plistPath)) {
+      return { ok: false, message: "Plist not found. Run writeDaemonUnit first." };
+    }
+    try {
+      await execFileImpl("launchctl", ["load", plistPath], { timeout: 5000 });
+      return { ok: true };
+    } catch (err) {
+      return { ok: false, message: `launchctl load failed: ${err.message}` };
+    }
+  }
+
+  if (platform === "linux") {
+    if (!existsImpl(join(getSystemdUserDir(), SYSTEMD_UNIT))) {
+      return { ok: false, message: "Systemd unit not found. Run writeDaemonUnit first." };
+    }
+    try {
+      await execFileImpl("systemctl", ["--user", "daemon-reload"], { timeout: 5000 });
+      await execFileImpl("systemctl", ["--user", "enable", "--now", SYSTEMD_UNIT], { timeout: 10000 });
+      return { ok: true };
+    } catch (err) {
+      return { ok: false, message: `systemctl enable+start failed: ${err.message}` };
+    }
+  }
+
+  // Windows — PM2
+  if (platform === "win32") {
+    const info = detectPlatform();
+    if (!info.hasPm2) {
+      return {
+        ok: false,
+        message: "PM2 not found. Run `nemoris setup` first, or start the daemon manually with `node src/cli.js serve-daemon live`.",
+      };
+    }
+    const { stdout: whichOut } = await execFileImpl("where", ["nemoris"]).catch(() => ({ stdout: "" }));
+    const nemorisBin = whichOut.trim().split("\n")[0] || join(installDir, "src", "cli.js");
+    try {
+      await execFileImpl("pm2", ["start", nemorisBin, "--name", "nemoris", "--", "serve-daemon", "live"], { timeout: 10000 });
+      await execFileImpl("pm2", ["save"], { timeout: 5000 });
+      return { ok: true };
+    } catch (err) {
+      return { ok: false, message: `PM2 start failed: ${err.message}` };
+    }
+  }
+
+  return { ok: false, message: `Unsupported platform: ${platform}` };
+}
+
+// ── unloadDaemon ─────────────────────────────────────────────────
+
+export async function unloadDaemon() {
+  const platform = process.platform;
+
+  if (platform === "darwin") {
+    for (const name of PLIST_NAMES) {
+      const p = join(getLaunchAgentsDir(), name);
+      if (existsSync(p)) {
+        try {
+          await execFile("launchctl", ["unload", p], { timeout: 5000 });
+          console.log(`  \u2713 Daemon unloaded (${name})`);
+        } catch (_) {
+          console.log(`  \u00b7 Daemon not running (${name})`);
+        }
+        try {
+          rmSync(p);
+          console.log(`  \u2713 Plist removed (${name})`);
+        } catch (e) {
+          console.warn(`  \u26a0 Could not remove plist: ${e.message}`);
+        }
+      }
+    }
+    return;
+  }
+
+  if (platform === "linux") {
+    try {
+      await execFile("systemctl", ["--user", "stop", SYSTEMD_UNIT], { timeout: 5000 });
+      console.log(`  \u2713 Daemon stopped`);
+    } catch (_) {
+      console.log(`  \u00b7 Daemon not running`);
+    }
+    try {
+      await execFile("systemctl", ["--user", "disable", SYSTEMD_UNIT], { timeout: 5000 });
+      console.log(`  \u2713 Daemon disabled`);
+    } catch (_) { /* noop */ }
+    const unitPath = join(getSystemdUserDir(), SYSTEMD_UNIT);
+    if (existsSync(unitPath)) {
+      try {
+        rmSync(unitPath);
+        console.log(`  \u2713 Unit file removed`);
+      } catch (e) {
+        console.warn(`  \u26a0 Could not remove unit file: ${e.message}`);
+      }
+    }
+    return;
+  }
+
+  if (platform === "win32") {
+    try {
+      await execFile("pm2", ["delete", "nemoris"], { timeout: 5000 });
+      console.log(`  \u2713 PM2 process deleted`);
+    } catch (_) {
+      console.log(`  \u00b7 PM2 process not found`);
+    }
+    try {
+      await execFile("pm2", ["save"], { timeout: 5000 });
+    } catch (_) { /* noop */ }
+  }
+}
+
+export async function stopDaemonService({ platform = process.platform, execFileImpl = execFile, existsImpl = existsSync } = {}) {
+  if (platform === "darwin") {
+    const plistName = PLIST_NAMES.find((name) => existsImpl(join(getLaunchAgentsDir(), name)));
+    if (!plistName) {
+      return { ok: false, notRunning: true, message: "No launchd unit found." };
+    }
+    try {
+      await execFileImpl("launchctl", ["unload", join(getLaunchAgentsDir(), plistName)], { timeout: 5000 });
+      return { ok: true };
+    } catch (err) {
+      const message = String(err?.message || "");
+      if (/could not find|no such process|not loaded/i.test(message)) {
+        return { ok: false, notRunning: true, message };
+      }
+      return { ok: false, message: `launchctl unload failed: ${message}` };
+    }
+  }
+
+  if (platform === "linux") {
+    if (!existsImpl(join(getSystemdUserDir(), SYSTEMD_UNIT))) {
+      return { ok: false, notRunning: true, message: "No systemd unit found." };
+    }
+    try {
+      await execFileImpl("systemctl", ["--user", "stop", SYSTEMD_UNIT], { timeout: 5000 });
+      return { ok: true };
+    } catch (err) {
+      const message = String(err?.message || "");
+      if (/not loaded|not found|inactive/i.test(message)) {
+        return { ok: false, notRunning: true, message };
+      }
+      return { ok: false, message: `systemctl stop failed: ${message}` };
+    }
+  }
+
+  if (platform === "win32") {
+    const info = detectPlatform();
+    if (!info.hasPm2) {
+      return { ok: false, notRunning: true, message: "PM2 not installed." };
+    }
+    try {
+      await execFileImpl("pm2", ["stop", "nemoris"], { timeout: 5000 });
+      await execFileImpl("pm2", ["save"], { timeout: 5000 });
+      return { ok: true };
+    } catch (err) {
+      const message = String(err?.message || "");
+      if (/not found|not exist|process or namespace/i.test(message)) {
+        return { ok: false, notRunning: true, message };
+      }
+      return { ok: false, message: `PM2 stop failed: ${message}` };
+    }
+  }
+
+  return { ok: false, notRunning: true, message: `Unsupported platform: ${platform}` };
+}
+
+// ── isDaemonRunning (SYNCHRONOUS) ────────────────────────────────
+
+export function isDaemonRunning() {
+  const platform = process.platform;
+
+  if (platform === "darwin") {
+    try {
+      const { status } = spawnSync(
+        "launchctl", ["list", "ai.nemoris.daemon"],
+        { timeout: 3000, stdio: "pipe" },
+      );
+      return status === 0;
+    } catch {
+      return false;
+    }
+  }
+
+  if (platform === "linux") {
+    try {
+      const { status } = spawnSync(
+        "systemctl", ["--user", "is-active", "--quiet", SYSTEMD_UNIT],
+        { timeout: 3000, stdio: "pipe" },
+      );
+      return status === 0;
+    } catch {
+      return false;
+    }
+  }
+
+  if (platform === "win32") {
+    try {
+      const { stdout, status } = spawnSync(
+        "pm2", ["jlist"],
+        { timeout: 5000, stdio: "pipe" },
+      );
+      if (status !== 0) return false;
+      const list = JSON.parse(stdout.toString());
+      return list.some((p) => p.name === "nemoris" && p.pm2_env?.status === "online");
+    } catch {
+      return false;
+    }
+  }
+
+  return false;
+}
+
+// ── setDaemonEnv ─────────────────────────────────────────────────
+
+export async function setDaemonEnv(key, value) {
+  const platform = process.platform;
+
+  if (platform === "darwin") {
+    try {
+      await execFile("launchctl", ["setenv", key, value], { timeout: 3000 });
+    } catch {
+      // Non-fatal — daemon restart will pick it up from .env
+    }
+    return;
+  }
+
+  if (platform === "linux") {
+    // Write to env file that systemd EnvironmentFile reads
+    try {
+      const daemonEnvDir = getDaemonEnvDir();
+      const daemonEnvFile = getDaemonEnvFile();
+      mkdirSync(daemonEnvDir, { recursive: true });
+      let content = "";
+      try {
+        content = readFileSync(daemonEnvFile, "utf8");
+      } catch { /* file doesn't exist yet */ }
+
+      const re = new RegExp(`^${key}=.*$`, "m");
+      const line = `${key}=${value}`;
+      if (re.test(content)) {
+        content = content.replace(re, line);
+      } else {
+        content = content.trimEnd() + (content ? "\n" : "") + line + "\n";
+      }
+      writeFileSync(daemonEnvFile, content, "utf8");
+    } catch {
+      // Non-fatal
+    }
+    return;
+  }
+
+  // Windows / other — noop (PM2 reads from process.env / .env)
+}
+
+// ── getDaemonEnv ─────────────────────────────────────────────────
+
+export async function getDaemonEnv(name, { execFileImpl = execFile, platform = process.platform } = {}) {
+  if (!name) {
+    return { value: null, source: null };
+  }
+
+  // Always check process.env first
+  const direct = process.env[name];
+  if (direct) {
+    return { value: direct, source: "process_env" };
+  }
+
+  if (platform === "darwin") {
+    try {
+      const { stdout } = await execFileImpl("launchctl", ["getenv", name], {
+        timeout: 2000,
+        maxBuffer: 64 * 1024,
+      });
+      const val = stdout.trim();
+      if (val) {
+        return { value: val, source: "launchctl" };
+      }
+    } catch {
+      // fall through
+    }
+    return { value: null, source: null };
+  }
+
+  if (platform === "linux") {
+    try {
+      const content = readFileSync(getDaemonEnvFile(), "utf8");
+      const re = new RegExp(`^${name}=(.*)$`, "m");
+      const m = content.match(re);
+      if (m) {
+        return { value: m[1], source: "env_file" };
+      }
+    } catch {
+      // fall through
+    }
+    return { value: null, source: null };
+  }
+
+  return { value: null, source: null };
+}