resumecontext 0.1.3 → 0.1.4

package/dist/commands/daemon.js

@@ -81,7 +81,7 @@ export async function runDaemonStart(ensureDaemonRunningFn = ensureDaemonRunning
     const platform = detectPlatform();
     const result = platform === "unsupported" ? { platform, installed: false } : ensureDaemonRunningFn();
     printDaemonNotice(result);
-    if (result.platform === "unsupported" || result.location === "temporary") {
+    if (result.platform === "unsupported" || result.location === "temporary" || result.error) {
         ui.outro(result.platform === "unsupported" ? "Not available." : "Not started.");
         return { started: false };
     }

package/dist/daemon.js

@@ -49,7 +49,7 @@ import { readAgentConfig } from "./agentConfig.js";
 import { readCredentials } from "./session.js";
 import { scanForNewTurns, pushNewTurns } from "./syncCore.js";
 import { MAX_LOG_BYTES } from "./constants.js";
-import { DAEMON_SUBCOMMAND, detectPlatform, installPersistentService } from "./daemonService.js";
+import { DAEMON_SUBCOMMAND, detectPlatform, installPersistentService, stopsAtLogout } from "./daemonService.js";
 import { installLocation } from "./packageInstall.js";
 import { fingerprintDirsForConfig } from "./localHistory/registry.js";
 import { findProjectRoot } from "./projectRoot.js";
@@ -98,7 +98,6 @@ export function deregisterProject(projectId) {
     fs.rmSync(agentConfigFile(projectId), { force: true });
     fs.rmSync(syncStateFile(projectId), { force: true });
 }
-// ---- lifecycle: making sure auto-sync is scheduled with the OS --------
 /** Registers auto-sync as a real OS-managed schedule if this platform
  * supports one (see daemonService.ts) -- no fallback of any kind on a
  * platform with neither launchd nor systemd, so what's registered is
@@ -119,10 +118,17 @@ export function deregisterProject(projectId) {
  * `installService` is injectable so tests can verify what would be
  * installed -- which mechanism, which plan -- without ever registering a
  * real OS service. */
-export function ensureDaemonRunning(installService = installPersistentService, location = installLocation()) {
+export function ensureDaemonRunning(installService = installPersistentService, location = installLocation(), checkStopsAtLogout = stopsAtLogout) {
     if (location === "temporary")
         return { platform: detectPlatform(), installed: false, location };
-    return { ...installService(), location };
+    try {
+        const result = { ...installService(), location };
+        // Only on a fresh registration, so this runs once, not on every command.
+        return result.installed && checkStopsAtLogout() ? { ...result, stopsAtLogout: true } : result;
+    }
+    catch (err) {
+        return { platform: detectPlatform(), installed: false, location, error: err instanceof Error ? err.message : String(err) };
+    }
 }
 // ---- log rotation -------------------------------------------------------
 /** Keeps daemonLogFile() bounded, retaining one previous generation.

package/dist/daemonNotices.js

@@ -5,10 +5,19 @@ export function printDaemonNotice(result) {
             "Install it with `npm install -g resumecontext` to sync in the background. `resumecontext sync` still works.");
         return;
     }
+    if (result.error) {
+        ui.log.warn(`Auto-sync couldn't be set up: ${result.error}\n` +
+            "Everything else works, and `resumecontext sync` syncs by hand. Run `resumecontext daemon start` to retry.");
+        return;
+    }
     if (result.platform === "unsupported") {
         ui.log.warn("Auto-sync isn't available on this OS (no launchd or systemd found) -- run `resumecontext sync` manually.");
         return;
     }
+    if (result.stopsAtLogout) {
+        ui.log.warn("Auto-sync will stop when you log out of this machine. To keep it running (for example on a server), run:\n" +
+            "  sudo loginctl enable-linger $USER");
+    }
     // Only when (re)registered, which is the first run and after an update --
     // not on every command.
     if (result.location === "folder" && result.installed) {

package/dist/daemonService.js

@@ -171,16 +171,23 @@ ${envBlock}  <key>RunAtLoad</key>
         afterRemoveCommands: [],
     };
 }
+export function systemdScope() {
+    return process.getuid?.() === 0 ? "system" : "user";
+}
 /** Same `version` parameter and reasoning as buildLaunchdPlan above. */
-export function buildSystemdPlan(homeDir = os.homedir(), version = cliVersion()) {
+export function buildSystemdPlan(homeDir = os.homedir(), version = cliVersion(), scope = "user") {
     const args = daemonProgramArguments();
     const logFile = daemonLogFile();
     const { systemdService: SYSTEMD_SERVICE_UNIT, systemdTimer: SYSTEMD_TIMER_UNIT } = serviceNames();
-    const systemdUserDir = path.join(homeDir, ".config", "systemd", "user");
-    const servicePath = path.join(systemdUserDir, SYSTEMD_SERVICE_UNIT);
-    const timerPath = path.join(systemdUserDir, SYSTEMD_TIMER_UNIT);
+    const unitDir = scope === "system" ? "/etc/systemd/system" : path.join(homeDir, ".config", "systemd", "user");
+    const servicePath = path.join(unitDir, SYSTEMD_SERVICE_UNIT);
+    const timerPath = path.join(unitDir, SYSTEMD_TIMER_UNIT);
     const quote = (s) => (/\s/.test(s) ? `"${s.replace(/"/g, '\\"')}"` : s);
-    const envLines = Object.entries(daemonEnvironment())
+    const systemctl = scope === "system" ? ["systemctl"] : ["systemctl", "--user"];
+    // A system service gets no $HOME of its own; set it, so every "~" the
+    // CLI resolves (its state, each agent's history) is the installing user's.
+    const env = scope === "system" ? { HOME: homeDir, ...daemonEnvironment() } : daemonEnvironment();
+    const envLines = Object.entries(env)
         .map(([k, v]) => `Environment=${k}=${quote(v)}\n`)
         .join("");
     const serviceContents = `# resumecontext-cli-version: ${version}
@@ -196,13 +203,16 @@ StandardError=append:${logFile}
     // OnBootSec=0 fires the first tick immediately once the timer starts
     // (mirrors launchd's RunAtLoad); OnUnitActiveSec counts from when the
     // triggered service last finished, not from a fixed clock, so a slow
-    // tick doesn't cause the next one to fire early or overlap.
+    // tick doesn't cause the next one to fire early or overlap. AccuracySec:
+    // systemd otherwise lets a timer fire anywhere in a 1-minute window, which
+    // turned a 20s interval into 20-60s.
     const timerContents = `[Unit]
 Description=resumecontext auto-sync timer
 
 [Timer]
 OnBootSec=0
 OnUnitActiveSec=${DAEMON_INTERVAL_SECONDS}s
+AccuracySec=1s
 Unit=${SYSTEMD_SERVICE_UNIT}
 
 [Install]
@@ -214,28 +224,55 @@ WantedBy=timers.target
             { path: timerPath, contents: timerContents },
         ],
         // Checks the TIMER, not the oneshot service -- see ServicePlan's doc.
-        statusCommand: ["systemctl", "--user", "is-active", "--quiet", SYSTEMD_TIMER_UNIT],
+        statusCommand: [...systemctl, "is-active", "--quiet", SYSTEMD_TIMER_UNIT],
         // Enabling/starting the TIMER is what schedules the service; the
         // service unit itself is never enabled or started directly.
         installCommands: [
-            ["systemctl", "--user", "daemon-reload"],
-            ["systemctl", "--user", "enable", "--now", SYSTEMD_TIMER_UNIT],
+            [...systemctl, "daemon-reload"],
+            [...systemctl, "enable", "--now", SYSTEMD_TIMER_UNIT],
         ],
-        uninstallCommands: [["systemctl", "--user", "disable", "--now", SYSTEMD_TIMER_UNIT]],
+        uninstallCommands: [[...systemctl, "disable", "--now", SYSTEMD_TIMER_UNIT]],
         // Stopping the timer does not stop a oneshot run it already started.
-        stopRunningCommands: [["systemctl", "--user", "stop", SYSTEMD_SERVICE_UNIT]],
-        afterRemoveCommands: [["systemctl", "--user", "daemon-reload"]],
+        stopRunningCommands: [[...systemctl, "stop", SYSTEMD_SERVICE_UNIT]],
+        afterRemoveCommands: [[...systemctl, "daemon-reload"]],
     };
 }
-export function buildPlan(platform, homeDir, version) {
+export function buildPlan(platform, homeDir, version, scope = systemdScope()) {
     if (platform === "launchd")
         return buildLaunchdPlan(homeDir, version);
     if (platform === "systemd")
-        return buildSystemdPlan(homeDir, version);
+        return buildSystemdPlan(homeDir, version, scope);
     return null;
 }
-function defaultExec(command, args) {
-    execFileSync(command, args, { stdio: "ignore" });
+export function defaultExec(command, args) {
+    try {
+        execFileSync(command, args, { stdio: ["ignore", "ignore", "pipe"] });
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            throw new Error(`\`${command}\` was not found on this machine`);
+        const stderr = String(err.stderr ?? "").trim();
+        throw new Error(`\`${[command, ...args].join(" ")}\` failed${stderr ? `: ${stderr}` : ""}`);
+    }
+}
+/**
+ * True when a user-scope systemd timer will stop the moment this user logs
+ * out -- the normal state for an SSH account on a server, and invisible
+ * until syncing quietly stops. False when lingering is on, for system scope,
+ * or when it can't be determined.
+ */
+export function stopsAtLogout(run = defaultRun) {
+    if (detectPlatform() !== "systemd" || systemdScope() !== "user")
+        return false;
+    try {
+        return run("loginctl", ["show-user", os.userInfo().username, "--property=Linger", "--value"]).trim() === "no";
+    }
+    catch {
+        return false;
+    }
+}
+function defaultRun(command, args) {
+    return execFileSync(command, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
 }
 /** True if `plan`'s schedule is already registered/active. */
 export function isServiceActive(execImpl = defaultExec, homeDir) {
@@ -250,6 +287,46 @@ export function isServiceActive(execImpl = defaultExec, homeDir) {
         return false;
     }
 }
+/**
+ * Registrations an earlier version may have left that the current plan
+ * replaces. Today that is one case: root on systemd used to get a USER timer
+ * (~/.config/systemd/user) and now gets a system one. Left in place, it would
+ * keep firing a second timer -- and survive `daemon stop` and `uninstall`,
+ * which only know the current plan.
+ */
+function supersededPlans(platform, homeDir) {
+    return platform === "systemd" && systemdScope() === "system" ? [buildSystemdPlan(homeDir, undefined, "user")] : [];
+}
+/** Best effort, and a no-op unless one of their files is actually on disk --
+ * so the common case runs no commands at all. */
+function removeSupersededPlans(platform, homeDir, execImpl, fsImpl) {
+    let removed = false;
+    for (const plan of supersededPlans(platform, homeDir)) {
+        const present = plan.files.filter((f) => fsImpl.existsSync(f.path));
+        if (present.length === 0)
+            continue;
+        for (const [cmd, ...args] of [...plan.uninstallCommands, ...plan.stopRunningCommands]) {
+            try {
+                execImpl(cmd, args);
+            }
+            catch {
+                // that manager may not even be reachable -- removing the files is what matters
+            }
+        }
+        for (const file of present)
+            fsImpl.unlinkSync(file.path);
+        for (const [cmd, ...args] of plan.afterRemoveCommands) {
+            try {
+                execImpl(cmd, args);
+            }
+            catch {
+                // best effort
+            }
+        }
+        removed = true;
+    }
+    return removed;
+}
 function readFileIfPresent(fsImpl, filePath) {
     try {
         return fsImpl.readFileSync(filePath, "utf8");
@@ -270,6 +347,13 @@ export function installPersistentService(fsImpl = fs, execImpl = defaultExec, ho
     const plan = buildPlan(platform, homeDir);
     if (!plan)
         return { platform, installed: false };
+    // systemd refuses to start a unit whose StandardOutput=append: file sits
+    // in a directory that doesn't exist ("Failed to set up standard output",
+    // status 209) -- and nothing else creates it until a project is added.
+    // Created on every call, before the early return, so a deleted directory
+    // is repaired by the next command too.
+    fsImpl.mkdirSync(path.dirname(daemonLogFile()), { recursive: true });
+    removeSupersededPlans(platform, homeDir, execImpl, fsImpl);
     // "Already active" is NOT enough to skip: what's registered could be
     // running the WRONG program, or an OUTDATED one. Two distinct cases,
     // both covered by the same plain string comparison:
@@ -313,6 +397,7 @@ export function uninstallPersistentService(execImpl = defaultExec, homeDir, fsIm
     if (!plan)
         return { platform, uninstalled: false };
     const wasActive = isServiceActive(execImpl, homeDir);
+    const removedSuperseded = removeSupersededPlans(platform, homeDir, execImpl, fsImpl);
     for (const [cmd, ...args] of [...plan.uninstallCommands, ...plan.stopRunningCommands]) {
         try {
             execImpl(cmd, args);
@@ -338,5 +423,5 @@ export function uninstallPersistentService(execImpl = defaultExec, homeDir, fsIm
             }
         }
     }
-    return { platform, uninstalled: wasActive || removedFiles };
+    return { platform, uninstalled: wasActive || removedFiles || removedSuperseded };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "resumecontext",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Sync your coding-agent sessions to a shared archive your agents can search over MCP.",
   "keywords": [
     "mcp",