@seedvault/cli 0.1.3 → 0.2.0

package/bin/sv.mjs

@@ -1,10 +1,5 @@
-#!/usr/bin/env node
-import { execFileSync } from "child_process";
+#!/usr/bin/env bun
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 const __dirname = dirname(fileURLToPath(import.meta.url));
-try {
-  execFileSync("bun", [join(__dirname, "..", "dist", "sv.js"), ...process.argv.slice(2)], { stdio: "inherit" });
-} catch (e) {
-  process.exit(e.status || 1);
-}
+await import(join(__dirname, "..", "dist", "sv.js"));

package/dist/sv.js

@@ -12,12 +12,25 @@ import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
 var CONFIG_DIR = join(homedir(), ".config", "seedvault");
 var CONFIG_PATH = join(CONFIG_DIR, "config.json");
 var PID_PATH = join(CONFIG_DIR, "daemon.pid");
-function getConfigDir() {
-  return CONFIG_DIR;
-}
+var DAEMON_LOG_PATH = join(CONFIG_DIR, "daemon.log");
+var LAUNCHD_PLIST_PATH = join(homedir(), "Library", "LaunchAgents", "ai.seedvault.daemon.plist");
+var SYSTEMD_UNIT_PATH = join(homedir(), ".config", "systemd", "user", "seedvault.service");
+var SCHTASKS_XML_PATH = join(CONFIG_DIR, "seedvault-task.xml");
 function getPidPath() {
   return PID_PATH;
 }
+function getDaemonLogPath() {
+  return DAEMON_LOG_PATH;
+}
+function getLaunchdPlistPath() {
+  return LAUNCHD_PLIST_PATH;
+}
+function getSystemdUnitPath() {
+  return SYSTEMD_UNIT_PATH;
+}
+function getSchtasksXmlPath() {
+  return SCHTASKS_XML_PATH;
+}
 function ensureConfigDir() {
   if (!existsSync(CONFIG_DIR)) {
     mkdirSync(CONFIG_DIR, { recursive: true });
@@ -402,7 +415,7 @@ async function collections() {
 }
 
 // src/commands/start.ts
-import { writeFileSync as writeFileSync2, unlinkSync } from "fs";
+import { writeFileSync as writeFileSync2, unlinkSync as unlinkSync2 } from "fs";
 
 // ../node_modules/.bun/chokidar@4.0.3/node_modules/chokidar/esm/index.js
 import { stat as statcb } from "fs";
@@ -2271,13 +2284,350 @@ async function walkDirRecursive(dir, results) {
   }
 }
 
+// src/daemon/service.ts
+import { resolve as resolve5, dirname as dirname3 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, unlinkSync } from "fs";
+var TASK_NAME = "SeedvaultDaemon";
+function detectPlatform() {
+  if (process.platform === "darwin")
+    return "macos";
+  if (process.platform === "linux")
+    return "linux";
+  if (process.platform === "win32")
+    return "windows";
+  throw new Error(`Unsupported platform: ${process.platform}. Only macOS, Linux, and Windows are supported.`);
+}
+function resolveBunPath() {
+  const which = Bun.which("bun");
+  if (which)
+    return which;
+  if (process.platform === "win32") {
+    const fallback = resolve5(process.env.USERPROFILE || process.env.HOME || "~", ".bun", "bin", "bun.exe");
+    if (existsSync3(fallback))
+      return fallback;
+  } else {
+    const fallback = resolve5(process.env.HOME || "~", ".bun", "bin", "bun");
+    if (existsSync3(fallback))
+      return fallback;
+  }
+  throw new Error("Cannot find bun executable. Ensure bun is in your PATH.");
+}
+function resolveSvPath() {
+  return resolve5(process.argv[1]);
+}
+async function runCommand(cmd, args) {
+  const proc = Bun.spawn([cmd, ...args], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [stdout2, stderr] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text()
+  ]);
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    throw new Error(`Command failed: ${cmd} ${args.join(" ")}
+${stderr.trim() || stdout2.trim()}`);
+  }
+  return { stdout: stdout2.trim(), stderr: stderr.trim() };
+}
+function generatePlist(bunPath, svPath, logPath) {
+  return `<?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.seedvault.daemon</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${bunPath}</string>
+    <string>${svPath}</string>
+    <string>start</string>
+    <string>--foreground</string>
+  </array>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>ThrottleInterval</key>
+  <integer>5</integer>
+  <key>StandardOutPath</key>
+  <string>${logPath}</string>
+  <key>StandardErrorPath</key>
+  <string>${logPath}</string>
+</dict>
+</plist>
+`;
+}
+function generateUnit(bunPath, svPath, logPath) {
+  return `[Unit]
+Description=Seedvault Sync Daemon
+
+[Service]
+ExecStart=${bunPath} ${svPath} start --foreground
+Restart=on-failure
+RestartSec=5
+StandardOutput=append:${logPath}
+StandardError=append:${logPath}
+
+[Install]
+WantedBy=default.target
+`;
+}
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function generateTaskXml(bunPath, svPath, logPath) {
+  const eBun = escapeXml(bunPath);
+  const eSv = escapeXml(svPath);
+  const eLog = escapeXml(logPath);
+  return `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>Seedvault Sync Daemon</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+    </LogonTrigger>
+  </Triggers>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <RestartOnFailure>
+      <Interval>PT5S</Interval>
+      <Count>999</Count>
+    </RestartOnFailure>
+  </Settings>
+  <Actions>
+    <Exec>
+      <Command>cmd</Command>
+      <Arguments>/c "${eBun}" "${eSv}" start --foreground &gt;&gt; "${eLog}" 2&gt;&amp;1</Arguments>
+    </Exec>
+  </Actions>
+</Task>
+`;
+}
+async function installService() {
+  const platform = detectPlatform();
+  const bunPath = resolveBunPath();
+  const svPath = resolveSvPath();
+  const logPath = getDaemonLogPath();
+  ensureConfigDir();
+  if (platform === "macos") {
+    await installMacos(bunPath, svPath, logPath);
+  } else if (platform === "linux") {
+    await installLinux(bunPath, svPath, logPath);
+  } else {
+    await installWindows(bunPath, svPath, logPath);
+  }
+}
+async function installMacos(bunPath, svPath, logPath) {
+  const plistPath = getLaunchdPlistPath();
+  const plistDir = dirname3(plistPath);
+  if (!existsSync3(plistDir)) {
+    mkdirSync2(plistDir, { recursive: true });
+  }
+  if (existsSync3(plistPath)) {
+    try {
+      await runCommand("launchctl", ["unload", plistPath]);
+    } catch {}
+  }
+  await Bun.write(plistPath, generatePlist(bunPath, svPath, logPath));
+  await runCommand("launchctl", ["load", plistPath]);
+  console.log("Seedvault daemon registered with launchd.");
+  console.log(`  Service: ai.seedvault.daemon`);
+  console.log(`  Log:     ${logPath}`);
+  console.log(`  The daemon will auto-restart on crash and start on login.`);
+  console.log(`  Run 'sv status' to check, 'sv stop' to unregister.`);
+}
+async function installLinux(bunPath, svPath, logPath) {
+  const unitPath = getSystemdUnitPath();
+  const unitDir = dirname3(unitPath);
+  if (!existsSync3(unitDir)) {
+    mkdirSync2(unitDir, { recursive: true });
+  }
+  if (existsSync3(unitPath)) {
+    try {
+      await runCommand("systemctl", ["--user", "disable", "--now", "seedvault.service"]);
+    } catch {}
+  }
+  await Bun.write(unitPath, generateUnit(bunPath, svPath, logPath));
+  await runCommand("systemctl", ["--user", "daemon-reload"]);
+  await runCommand("systemctl", ["--user", "enable", "--now", "seedvault.service"]);
+  console.log("Seedvault daemon registered with systemd.");
+  console.log(`  Service: seedvault.service`);
+  console.log(`  Log:     ${logPath}`);
+  console.log(`  The daemon will auto-restart on crash and start on login.`);
+  console.log(`  Run 'sv status' to check, 'sv stop' to unregister.`);
+}
+async function installWindows(bunPath, svPath, logPath) {
+  const xmlPath = getSchtasksXmlPath();
+  try {
+    await runCommand("schtasks", ["/Delete", "/TN", TASK_NAME, "/F"]);
+  } catch {}
+  await Bun.write(xmlPath, generateTaskXml(bunPath, svPath, logPath));
+  await runCommand("schtasks", ["/Create", "/TN", TASK_NAME, "/XML", xmlPath, "/F"]);
+  await runCommand("schtasks", ["/Run", "/TN", TASK_NAME]);
+  console.log("Seedvault daemon registered with Windows Task Scheduler.");
+  console.log(`  Task:    ${TASK_NAME}`);
+  console.log(`  Log:     ${logPath}`);
+  console.log(`  The daemon will auto-restart on failure and start on login.`);
+  console.log(`  Run 'sv status' to check, 'sv stop' to unregister.`);
+}
+async function uninstallService() {
+  const platform = detectPlatform();
+  if (platform === "macos") {
+    await uninstallMacos();
+  } else if (platform === "linux") {
+    await uninstallLinux();
+  } else {
+    await uninstallWindows();
+  }
+}
+async function uninstallMacos() {
+  const plistPath = getLaunchdPlistPath();
+  if (!existsSync3(plistPath)) {
+    console.log("No daemon service is registered.");
+    return;
+  }
+  try {
+    await runCommand("launchctl", ["unload", plistPath]);
+  } catch {}
+  unlinkSync(plistPath);
+  cleanupPidFile();
+  console.log("Daemon stopped and service unregistered.");
+}
+async function uninstallLinux() {
+  const unitPath = getSystemdUnitPath();
+  if (!existsSync3(unitPath)) {
+    console.log("No daemon service is registered.");
+    return;
+  }
+  try {
+    await runCommand("systemctl", ["--user", "disable", "--now", "seedvault.service"]);
+  } catch {}
+  unlinkSync(unitPath);
+  try {
+    await runCommand("systemctl", ["--user", "daemon-reload"]);
+  } catch {}
+  cleanupPidFile();
+  console.log("Daemon stopped and service unregistered.");
+}
+async function uninstallWindows() {
+  let taskExists = false;
+  try {
+    await runCommand("schtasks", ["/Query", "/TN", TASK_NAME]);
+    taskExists = true;
+  } catch {}
+  if (!taskExists) {
+    console.log("No daemon service is registered.");
+    return;
+  }
+  try {
+    await runCommand("schtasks", ["/End", "/TN", TASK_NAME]);
+  } catch {}
+  try {
+    await runCommand("schtasks", ["/Delete", "/TN", TASK_NAME, "/F"]);
+  } catch {}
+  const xmlPath = getSchtasksXmlPath();
+  if (existsSync3(xmlPath)) {
+    try {
+      unlinkSync(xmlPath);
+    } catch {}
+  }
+  cleanupPidFile();
+  console.log("Daemon stopped and service unregistered.");
+}
+function cleanupPidFile() {
+  const pidPath = getPidPath();
+  if (existsSync3(pidPath)) {
+    try {
+      unlinkSync(pidPath);
+    } catch {}
+  }
+}
+async function getServiceStatus() {
+  const platform = detectPlatform();
+  if (platform === "macos") {
+    return getStatusMacos();
+  } else if (platform === "linux") {
+    return getStatusLinux();
+  } else {
+    return getStatusWindows();
+  }
+}
+async function getStatusMacos() {
+  const plistPath = getLaunchdPlistPath();
+  if (!existsSync3(plistPath)) {
+    return { installed: false, running: false, pid: null };
+  }
+  try {
+    const { stdout: stdout2 } = await runCommand("launchctl", ["list", "ai.seedvault.daemon"]);
+    const pidMatch = stdout2.match(/"PID"\s*=\s*(\d+)/);
+    const pid = pidMatch ? parseInt(pidMatch[1], 10) : null;
+    return { installed: true, running: pid !== null, pid };
+  } catch {
+    return { installed: true, running: false, pid: null };
+  }
+}
+async function getStatusLinux() {
+  const unitPath = getSystemdUnitPath();
+  if (!existsSync3(unitPath)) {
+    return { installed: false, running: false, pid: null };
+  }
+  let running = false;
+  try {
+    const { stdout: stdout2 } = await runCommand("systemctl", ["--user", "is-active", "seedvault.service"]);
+    running = stdout2 === "active";
+  } catch {}
+  let pid = null;
+  if (running) {
+    try {
+      const { stdout: stdout2 } = await runCommand("systemctl", ["--user", "show", "--property=MainPID", "seedvault.service"]);
+      const match = stdout2.match(/MainPID=(\d+)/);
+      if (match) {
+        const parsed = parseInt(match[1], 10);
+        if (parsed > 0)
+          pid = parsed;
+      }
+    } catch {}
+  }
+  return { installed: true, running, pid };
+}
+async function getStatusWindows() {
+  try {
+    const { stdout: stdout2 } = await runCommand("schtasks", ["/Query", "/TN", TASK_NAME, "/FO", "CSV", "/NH"]);
+    const installed = true;
+    const running = stdout2.toLowerCase().includes("running");
+    let pid = null;
+    const pidPath = getPidPath();
+    if (running && existsSync3(pidPath)) {
+      try {
+        const content = await Bun.file(pidPath).text();
+        const parsed = parseInt(content.trim(), 10);
+        if (!isNaN(parsed) && parsed > 0)
+          pid = parsed;
+      } catch {}
+    }
+    return { installed, running, pid };
+  } catch {
+    return { installed: false, running: false, pid: null };
+  }
+}
+
 // src/commands/start.ts
 async function start(args) {
-  const daemonize = args.includes("-d") || args.includes("--daemon");
-  if (daemonize) {
-    return startBackground();
+  const foreground = args.includes("-f") || args.includes("--foreground");
+  if (foreground) {
+    return startForeground();
   }
-  return startForeground();
+  return installService();
 }
 async function startForeground() {
   let config = loadConfig();
@@ -2398,31 +2748,13 @@ async function startForeground() {
       watcher.close();
     syncer.stop();
     try {
-      unlinkSync(getPidPath());
+      unlinkSync2(getPidPath());
     } catch {}
     process.exit(0);
   };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
 }
-async function startBackground() {
-  loadConfig();
-  const entryPoint = import.meta.dir + "/../index.ts";
-  const logPath = getConfigDir() + "/daemon.log";
-  const child = Bun.spawn({
-    cmd: ["bun", "run", entryPoint, "start"],
-    stdin: "ignore",
-    stdout: Bun.file(logPath),
-    stderr: Bun.file(logPath),
-    env: { ...process.env }
-  });
-  const pid = child.pid;
-  writeFileSync2(getPidPath(), String(pid));
-  console.log(`Daemon started in background (PID ${pid}).`);
-  console.log(`  Log:  ${logPath}`);
-  console.log(`  Run 'sv status' to check, 'sv stop' to stop.`);
-  child.unref();
-}
 function keyByName(collections2) {
   const map = new Map;
   for (const collection of collections2) {
@@ -2455,46 +2787,11 @@ function reconcileCollections(prev, next) {
 }
 
 // src/commands/stop.ts
-import { readFileSync as readFileSync2, unlinkSync as unlinkSync2, existsSync as existsSync3 } from "fs";
 async function stop() {
-  const pidPath = getPidPath();
-  if (!existsSync3(pidPath)) {
-    console.log("No daemon is running (no PID file found).");
-    return;
-  }
-  const pid = parseInt(readFileSync2(pidPath, "utf-8").trim(), 10);
-  if (isNaN(pid)) {
-    console.error("Invalid PID file. Removing it.");
-    unlinkSync2(pidPath);
-    return;
-  }
-  try {
-    process.kill(pid, 0);
-  } catch {
-    console.log(`Daemon (PID ${pid}) is not running. Cleaning up PID file.`);
-    unlinkSync2(pidPath);
-    return;
-  }
-  try {
-    process.kill(pid, "SIGTERM");
-    console.log(`Sent SIGTERM to daemon (PID ${pid}).`);
-    await Bun.sleep(500);
-    try {
-      process.kill(pid, 0);
-      console.log("Daemon still running. Send SIGKILL with: kill -9 " + pid);
-    } catch {
-      console.log("Daemon stopped.");
-      try {
-        unlinkSync2(pidPath);
-      } catch {}
-    }
-  } catch (e) {
-    console.error(`Failed to stop daemon: ${e.message}`);
-  }
+  await uninstallService();
 }
 
 // src/commands/status.ts
-import { readFileSync as readFileSync3, existsSync as existsSync4 } from "fs";
 async function status() {
   if (!configExists()) {
     console.log("Not configured. Run 'sv init' first.");
@@ -2505,21 +2802,19 @@ async function status() {
 `);
   console.log(`  Server:  ${config.server}`);
   console.log(`  Contributor: ${config.contributorId}`);
-  const pidPath = getPidPath();
-  if (existsSync4(pidPath)) {
-    const pid = parseInt(readFileSync3(pidPath, "utf-8").trim(), 10);
-    let alive = false;
-    try {
-      process.kill(pid, 0);
-      alive = true;
-    } catch {}
-    if (alive) {
-      console.log(`  Daemon:  running (PID ${pid})`);
+  try {
+    const platform = detectPlatform();
+    const serviceName = platform === "macos" ? "launchd" : platform === "linux" ? "systemd" : "Task Scheduler";
+    const svc = await getServiceStatus();
+    if (!svc.installed) {
+      console.log(`  Daemon:  not registered (run 'sv start' to register)`);
+    } else if (svc.running) {
+      console.log(`  Daemon:  running via ${serviceName}${svc.pid ? ` (PID ${svc.pid})` : ""}`);
     } else {
-      console.log(`  Daemon:  not running (stale PID file)`);
+      console.log(`  Daemon:  registered via ${serviceName} but not running`);
     }
-  } else {
-    console.log("  Daemon:  not running");
+  } catch {
+    console.log("  Daemon:  unsupported platform");
   }
   if (config.collections.length === 0) {
     console.log("  Collections: none configured");
@@ -2644,9 +2939,9 @@ Collections:
   collections                   List configured collections
 
 Daemon:
-  start                         Start syncing (foreground)
-  start -d                      Start syncing (background)
-  stop                          Stop the daemon
+  start                         Register OS service and start syncing
+  start -f                      Start syncing in foreground (debug)
+  stop                          Stop daemon and unregister service
   status                        Show sync status
 
 Files:
@@ -2664,7 +2959,7 @@ async function main() {
     return;
   }
   if (cmd === "--version" || cmd === "-v") {
-    console.log("0.1.3");
+    console.log("0.2.0");
     return;
   }
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seedvault/cli",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "type": "module",
   "bin": {
     "sv": "bin/sv.mjs"