arisa 2.1.1 → 2.1.4

package/bin/arisa.js

@@ -403,6 +403,235 @@ function printForegroundNotice() {
   process.stdout.write("Use `arisa start` to run it as a background service.\n");
 }
 
+// ── Root detection helpers ──────────────────────────────────────────
+
+function isRoot() {
+  return process.getuid?.() === 0;
+}
+
+function arisaUserExists() {
+  return spawnSync("id", ["arisa"], { stdio: "ignore" }).status === 0;
+}
+
+function isProvisioned() {
+  return arisaUserExists() && existsSync("/home/arisa/.bun/bin/bun");
+}
+
+function detectSudoGroup() {
+  // Debian/Ubuntu use 'sudo', RHEL/Fedora use 'wheel'
+  const sudoGroup = spawnSync("getent", ["group", "sudo"], { stdio: "ignore" });
+  if (sudoGroup.status === 0) return "sudo";
+  const wheelGroup = spawnSync("getent", ["group", "wheel"], { stdio: "ignore" });
+  if (wheelGroup.status === 0) return "wheel";
+  return null;
+}
+
+function step(ok, msg) {
+  process.stdout.write(`  ${ok ? "\u2713" : "\u2717"} ${msg}\n`);
+}
+
+function runAsInherit(cmd) {
+  return spawnSync("su", ["-", "arisa", "-c", cmd], {
+    stdio: "inherit",
+    timeout: 180_000,
+  });
+}
+
+function provisionArisaUser() {
+  process.stdout.write("Running as root \u2014 creating dedicated user 'arisa'...\n");
+
+  // 1. Create user
+  const useradd = spawnSync("useradd", ["-m", "-s", "/bin/bash", "arisa"], {
+    stdio: "pipe",
+  });
+  if (useradd.status !== 0) {
+    step(false, `Failed to create user: ${(useradd.stderr || "").toString().trim()}`);
+    process.exit(1);
+  }
+  step(true, "User arisa created");
+
+  // Add to sudo/wheel group if available
+  const group = detectSudoGroup();
+  if (group) {
+    spawnSync("usermod", ["-aG", group, "arisa"], { stdio: "ignore" });
+  }
+
+  // 2. Install bun (downloads ~30 MB, may take a minute)
+  process.stdout.write("  Installing bun (this may take a minute)...\n");
+  const bunInstall = runAsInherit("curl -fsSL https://bun.sh/install | bash");
+  if (bunInstall.status !== 0) {
+    step(false, "Failed to install bun");
+    process.exit(1);
+  }
+  step(true, "Bun installed for arisa");
+
+  // 3. Copy arisa source
+  const dest = "/home/arisa/arisa";
+  spawnSync("cp", ["-r", pkgRoot, dest], { stdio: "pipe" });
+  spawnSync("chown", ["-R", "arisa:arisa", dest], { stdio: "pipe" });
+
+  // Install deps + global
+  process.stdout.write("  Installing dependencies...\n");
+  const install = runAsInherit("cd ~/arisa && ~/.bun/bin/bun install && ~/.bun/bin/bun add -g .");
+  if (install.status !== 0) {
+    step(false, "Failed to install dependencies");
+    process.exit(1);
+  }
+  step(true, "Arisa installed for arisa");
+
+  // 4. Migrate data
+  const rootArisa = "/root/.arisa";
+  if (existsSync(rootArisa)) {
+    const destArisa = "/home/arisa/.arisa";
+    spawnSync("cp", ["-r", rootArisa, destArisa], { stdio: "pipe" });
+    spawnSync("chown", ["-R", "arisa:arisa", destArisa], { stdio: "pipe" });
+    step(true, "Data migrated to /home/arisa/.arisa/");
+  }
+}
+
+// ── System-level systemd (for root-provisioned installs) ────────────
+
+const systemdSystemUnitPath = "/etc/systemd/system/arisa.service";
+
+function writeSystemdSystemUnit() {
+  const unit = `[Unit]
+Description=Arisa Agent Runtime
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=arisa
+WorkingDirectory=/home/arisa/arisa
+ExecStart=/home/arisa/.bun/bin/bun /home/arisa/arisa/src/daemon/index.ts
+Restart=always
+RestartSec=5
+Environment=ARISA_PROJECT_DIR=/home/arisa/arisa
+Environment=BUN_INSTALL=/home/arisa/.bun
+Environment=PATH=/home/arisa/.bun/bin:/usr/local/bin:/usr/bin:/bin
+
+[Install]
+WantedBy=multi-user.target
+`;
+  writeFileSync(systemdSystemUnitPath, unit, "utf8");
+}
+
+function runSystemdSystem(commandArgs) {
+  const child = runCommand("systemctl", commandArgs, { stdio: "pipe" });
+  if (child.status !== 0) {
+    const stderr = child.stderr || "Unknown systemd error";
+    process.stderr.write(stderr.endsWith("\n") ? stderr : `${stderr}\n`);
+    return { ok: false, status: child.status ?? 1 };
+  }
+  return { ok: true, status: 0, stdout: child.stdout || "" };
+}
+
+function startSystemdSystem() {
+  const start = runSystemdSystem(["start", "arisa"]);
+  if (!start.ok) return start.status;
+  process.stdout.write("Arisa service started.\n");
+  return 0;
+}
+
+function stopSystemdSystem() {
+  const stop = runSystemdSystem(["stop", "arisa"]);
+  if (!stop.ok) return stop.status;
+  process.stdout.write("Arisa service stopped.\n");
+  return 0;
+}
+
+function restartSystemdSystem() {
+  const restart = runSystemdSystem(["restart", "arisa"]);
+  if (!restart.ok) return restart.status;
+  process.stdout.write("Arisa service restarted.\n");
+  return 0;
+}
+
+function statusSystemdSystem() {
+  const result = runCommand("systemctl", ["status", "arisa"], { stdio: "inherit" });
+  return result.status ?? 1;
+}
+
+function isSystemdActive() {
+  const result = runCommand("systemctl", ["is-active", "arisa"], { stdio: "pipe" });
+  return result.status === 0;
+}
+
+// ── Root guard ──────────────────────────────────────────────────────
+
+if (isRoot()) {
+  if (!isProvisioned()) {
+    provisionArisaUser();
+    writeSystemdSystemUnit();
+    spawnSync("systemctl", ["daemon-reload"], { stdio: "inherit" });
+    spawnSync("systemctl", ["enable", "arisa"], { stdio: "inherit" });
+    step(true, "Systemd service enabled (auto-starts on reboot)");
+
+    process.stdout.write("\nStarting interactive setup as user arisa...\n\n");
+    const su = spawnSync("su", ["-", "arisa", "-c", "arisa"], {
+      stdio: "inherit",
+    });
+
+    process.stdout.write(`
+Arisa management:
+  Start:    systemctl start arisa
+  Status:   systemctl status arisa
+  Logs:     journalctl -u arisa -f
+  Restart:  systemctl restart arisa
+  Stop:     systemctl stop arisa
+`);
+    process.exit(su.status ?? 0);
+  }
+
+  // Already provisioned — route commands to system-level systemd
+  if (command === "help" || command === "--help" || command === "-h") {
+    printHelp();
+    process.exit(0);
+  }
+  if (command === "version" || command === "--version" || command === "-v") {
+    printVersion();
+    process.exit(0);
+  }
+
+  switch (command) {
+    case "start":
+      process.exit(startSystemdSystem());
+      break;
+    case "stop":
+      process.exit(stopSystemdSystem());
+      break;
+    case "restart":
+      process.exit(restartSystemdSystem());
+      break;
+    case "status":
+      process.exit(statusSystemdSystem());
+      break;
+    case "daemon":
+    case "run": {
+      // Run as arisa user in foreground
+      const su = spawnSync("su", ["-", "arisa", "-c", "arisa"], {
+        stdio: "inherit",
+      });
+      process.exit(su.status ?? 1);
+    }
+    default: {
+      // No args or unknown — start if not active, otherwise show status
+      if (isDefaultInvocation) {
+        if (isSystemdActive()) {
+          process.exit(statusSystemdSystem());
+        } else {
+          process.exit(startSystemdSystem());
+        }
+      }
+      process.stderr.write(`Unknown command: ${command}\n\n`);
+      printHelp();
+      process.exit(1);
+    }
+  }
+}
+
+// ── Non-root flow (unchanged) ───────────────────────────────────────
+
 if (command === "help" || command === "--help" || command === "-h") {
   printHelp();
   process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arisa",
-  "version": "2.1.1",
+  "version": "2.1.4",
   "description": "Arisa - dynamic agent runtime with daemon/core architecture that evolves through user interaction",
   "preferGlobal": true,
   "bin": {

package/src/core/scheduler.ts

@@ -59,7 +59,7 @@ async function executeTask(task: ScheduledTask) {
     if (!tasks.includes(task) || !result) return;
 
     // Send the processed result to Telegram via Daemon
-    const response = await fetch("http://localhost/daemon/send", {
+    const response = await fetch("http://localhost/send", {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({

package/src/daemon/autofix.ts

@@ -85,7 +85,7 @@ Rules:
       } else {
         const detail = outcome.failures.join(" | ").slice(0, 400);
         log.error(`Auto-fix: all CLIs failed: ${detail}`);
-        await notifyFn?.("Auto-fix: Claude y Codex fallaron. Revisá los logs.");
+        await notifyFn?.("Auto-fix: both Claude and Codex failed. Check the logs.");
       }
       return false;
     }
@@ -98,11 +98,11 @@ Rules:
       log.info(`Auto-fix: ${cli} completed successfully`);
     }
 
-    await notifyFn?.(`Auto-fix aplicado con ${cli}. Core reiniciando...\n<pre>${escapeHtml(summary)}</pre>`);
+    await notifyFn?.(`Auto-fix applied with ${cli}. Core restarting...\n<pre>${escapeHtml(summary)}</pre>`);
     return true;
   } catch (err) {
     log.error(`Auto-fix: error: ${err}`);
-    await notifyFn?.("Auto-fix: error interno. Revisá los logs.");
+    await notifyFn?.("Auto-fix: internal error. Check the logs.");
     return false;
   }
 }

package/src/daemon/bridge.ts

@@ -18,7 +18,7 @@ import { getCoreState, getCoreError, waitForCoreReady } from "./lifecycle";
 
 const log = createLogger("daemon");
 
-const CORE_URL = "http://localhost/core";
+const CORE_URL = "http://localhost";
 const STARTUP_WAIT_MS = 15_000;
 const RETRY_DELAY = 3000;
 
@@ -54,7 +54,7 @@ async function handleStarting(
   onStatus?: StatusCallback,
 ): Promise<CoreResponse> {
   log.info("Core is starting, waiting for it to be ready...");
-  await onStatus?.("Core iniciando, esperando...");
+  await onStatus?.("Core starting, please wait...");
 
   const ready = await waitForCoreReady(STARTUP_WAIT_MS);
 
@@ -90,7 +90,7 @@ async function handleUp(
   }
 
   log.warn("Core unreachable, retrying in 3s...");
-  await onStatus?.("Core no responde, reintentando...");
+  await onStatus?.("Core not responding, retrying...");
   await sleep(RETRY_DELAY);
 
   try {
@@ -114,9 +114,9 @@ async function runFallback(
 
   if (coreError) {
     const preview = coreError.length > 300 ? coreError.slice(-300) : coreError;
-    await onStatus?.(`Core caido. Error:\n<pre>${escapeHtml(preview)}</pre>\nConsultando fallback directo (Claude/Codex)...`);
+    await onStatus?.(`Core is down. Error:\n<pre>${escapeHtml(preview)}</pre>\nFalling back to direct CLI (Claude/Codex)...`);
   } else {
-    await onStatus?.("Core caido. Consultando fallback directo (Claude/Codex)...");
+    await onStatus?.("Core is down. Falling back to direct CLI (Claude/Codex)...");
   }
 
   const text = message.text || "[non-text message — media not available in fallback mode]";

package/src/daemon/lifecycle.ts

@@ -91,7 +91,7 @@ function startHealthCheck() {
       return;
     }
     try {
-      const res = await fetch("http://localhost/core/health", {
+      const res = await fetch("http://localhost/health", {
         signal: AbortSignal.timeout(2000),
         unix: config.coreSocket,
       } as any);
@@ -249,7 +249,7 @@ async function handleError(error: string) {
     const preview = error.length > 500 ? error.slice(-500) : error;
     log.warn("Core error detected, notifying and attempting auto-fix...");
     await notifyFn?.(
-      `Error en Core detectado:\n<pre>${escapeHtml(preview)}</pre>\nIntentando arreglar...`
+      `Core error detected:\n<pre>${escapeHtml(preview)}</pre>\nAttempting auto-fix...`
     );
 
     // 2. Run autofix
@@ -257,9 +257,9 @@ async function handleError(error: string) {
 
     // 3. Notify result
     if (fixed) {
-      await notifyFn?.("Auto-fix aplicado. Core se reiniciará automáticamente.");
+      await notifyFn?.("Auto-fix applied. Core will restart automatically.");
     } else {
-      await notifyFn?.("Auto-fix no pudo resolver el error. Revisalo manualmente.");
+      await notifyFn?.("Auto-fix could not resolve the error. Please check manually.");
     }
   } catch (err) {
     log.error(`handleError threw: ${err}`);

package/src/daemon/setup.ts

@@ -82,11 +82,11 @@ export async function runSetup(): Promise<boolean> {
     let token: string;
     if (inq) {
       token = await inq.input({
-        message: "Telegram Bot Token (from @BotFather):",
+        message: "Telegram Bot Token (from https://t.me/BotFather):",
         validate: (v) => (v.trim() ? true : "Token is required"),
       });
     } else {
-      console.log("Telegram Bot Token required. Get one from @BotFather on Telegram.");
+      console.log("Telegram Bot Token required. Get one from https://t.me/BotFather on Telegram.");
       token = await readLine("TELEGRAM_BOT_TOKEN: ");
     }