resumecontext 0.1.0 → 0.1.1

package/dist/agentConfigWithDaemon.js

@@ -17,13 +17,7 @@
  */
 import { ensureAgentConfig } from "./agentConfig.js";
 import { registerProject, ensureDaemonRunning } from "./daemon.js";
-import * as ui from "./ui.js";
-function warnIfDaemonUnsupported(ensureDaemonRunningFn) {
-    const { platform } = ensureDaemonRunningFn();
-    if (platform === "unsupported") {
-        ui.log.warn("Auto-sync isn't available on this OS (no launchd or systemd found) -- run `resumecontext sync` manually.");
-    }
-}
+import { printDaemonNotice } from "./daemonNotices.js";
 /** For every project-scoped command except `agents`: returns the config
  * that's already on disk, or runs the interactive prompt the first time --
  * either way, makes sure the daemon covers this project afterward. This is
@@ -37,6 +31,6 @@ function warnIfDaemonUnsupported(ensureDaemonRunningFn) {
 export async function ensureAgentConfigWithDaemon(projectId, root, ensureDaemonRunningFn = ensureDaemonRunning) {
     const config = await ensureAgentConfig(projectId);
     registerProject(projectId, root);
-    warnIfDaemonUnsupported(ensureDaemonRunningFn);
+    printDaemonNotice(ensureDaemonRunningFn());
     return config;
 }

package/dist/commands/auth.js

@@ -10,11 +10,9 @@ import { openInBrowser } from "../browser.js";
 import { sleep } from "../utils.js";
 import * as ui from "../ui.js";
 import { ensureDaemonRunning } from "../daemon.js";
+import { printDaemonNotice } from "../daemonNotices.js";
 function startDaemonAfterAuth(ensureDaemonRunningFn) {
-    const { platform } = ensureDaemonRunningFn();
-    if (platform === "unsupported") {
-        ui.log.warn("Auto-sync isn't available on this OS (no launchd or systemd found) -- run `resumecontext sync` manually.");
-    }
+    printDaemonNotice(ensureDaemonRunningFn());
 }
 async function pollForLogin(deps, deviceCode, pollIntervalMs, timeoutMs) {
     const deadline = Date.now() + timeoutMs;

package/dist/commands/daemon.js

@@ -16,8 +16,9 @@
  * this is rarely needed day to day -- it's here for after an explicit
  * `stop`, or to check "did that actually work" without waiting for the
  * next `sync`. */
-import { isServiceActive, installPersistentService, uninstallPersistentService, detectPlatform } from "../daemonService.js";
-import { readRegistry } from "../daemon.js";
+import { isServiceActive, uninstallPersistentService, detectPlatform } from "../daemonService.js";
+import { ensureDaemonRunning, readRegistry } from "../daemon.js";
+import { printDaemonNotice } from "../daemonNotices.js";
 import { findProjectRoot } from "../projectRoot.js";
 import * as ui from "../ui.js";
 /** Resolve each registry entry exactly as a daemon tick does, so status can
@@ -75,15 +76,16 @@ export async function runDaemonStatus() {
     ui.outro(running ? "Running." : "Not running.");
     return { running, projects };
 }
-export async function runDaemonStart() {
+export async function runDaemonStart(ensureDaemonRunningFn = ensureDaemonRunning) {
     ui.intro("daemon start");
     const platform = detectPlatform();
-    if (platform === "unsupported") {
-        ui.log.warn("Auto-sync isn't available on this OS (no launchd or systemd found) -- run `resumecontext sync` manually.");
-        ui.outro("Not available.");
+    const result = platform === "unsupported" ? { platform, installed: false } : ensureDaemonRunningFn();
+    printDaemonNotice(result);
+    if (result.platform === "unsupported" || result.location === "temporary") {
+        ui.outro(result.platform === "unsupported" ? "Not available." : "Not started.");
         return { started: false };
     }
-    const { installed } = installPersistentService();
+    const { installed } = result;
     ui.outro(installed
         ? `Auto-sync started (registered with ${platform === "launchd" ? "launchd" : "systemd"} -- survives crashes and reboots).`
         : "Auto-sync was already running.");

package/dist/commands/uninstall.js

@@ -1,14 +1,29 @@
 /**
- * `resumecontext uninstall` -- stops the background auto-sync service and
- * deletes every bit of local resumecontext state: credentials, every
- * project's sync progress and agent configuration, the daemon's project
- * registry and log. This is the one command in the whole CLI that can't
- * be undone by running another command afterward, so it asks for
- * confirmation first, defaulting to No.
+ * `resumecontext uninstall` -- removes every trace of the CLI from this
+ * machine:
+ *
+ *  - the background auto-sync schedule (launchd plist / systemd units), and
+ *    any sync tick running at that moment;
+ *  - all local state: credentials, device id, every project's sync progress
+ *    and agent configuration, the daemon's project registry and log;
+ *  - the globally installed npm package itself, when that is how it was
+ *    installed (otherwise it says how to remove it).
+ *
+ * Deliberately left: each project's `.resumecontext.json` marker. It lives in
+ * the user's repository and is meant to be committed and shared, so deleting
+ * it would change teammates' checkouts. uninstall lists where they are.
+ *
+ * This is the one command in the whole CLI that can't be undone by running
+ * another command afterward, so it asks for confirmation first, defaulting
+ * to No.
  */
 import fs from "node:fs";
 import os from "node:os";
+import path from "node:path";
 import { uninstallPersistentService } from "../daemonService.js";
+import { readRegistry, stopRunningTick } from "../daemon.js";
+import { isGlobalNpmInstall, removeGlobalNpmPackage, PACKAGE_NAME } from "../packageInstall.js";
+import { MARKER_FILENAME } from "../projectRoot.js";
 import { defaultResumecontextHome, KNOWN_HOME_ENTRIES, resumecontextHome } from "../paths.js";
 import * as ui from "../ui.js";
 /** True if it's safe to delete `dir` as resumecontext state. The default
@@ -27,9 +42,17 @@ function looksLikeResumecontextHome(dir) {
         return true;
     return entries.some((entry) => KNOWN_HOME_ENTRIES.has(entry));
 }
+/** Project folders registered on this machine that still hold a marker. */
+function projectMarkers() {
+    const roots = new Set(Object.values(readRegistry().projects).map((p) => p.root));
+    return [...roots].map((root) => path.join(root, MARKER_FILENAME)).filter((file) => fs.existsSync(file));
+}
 export async function runUninstall(opts = {}) {
     const confirmFn = opts.confirmFn ?? ((message) => ui.confirm(message, false));
     const uninstallService = opts.uninstallService ?? uninstallPersistentService;
+    const stopTick = opts.stopTick ?? (() => stopRunningTick());
+    const isGlobalInstall = opts.isGlobalInstall ?? (() => isGlobalNpmInstall());
+    const removePackage = opts.removePackage ?? (() => removeGlobalNpmPackage());
     ui.intro("uninstall");
     const home = resumecontextHome();
     // A misconfigured RESUMECONTEXT_HOME (empty, "/", or the real home
@@ -46,16 +69,42 @@ export async function runUninstall(opts = {}) {
     if (!looksLikeResumecontextHome(home)) {
         throw new Error(`Refusing to delete "${home}" -- it contains files resumecontext didn't create, so this doesn't look like a resumecontext state directory.`);
     }
+    const globalInstall = isGlobalInstall();
+    // Read before the registry is deleted along with everything else.
+    const markers = projectMarkers();
     ui.log.warn("This will stop auto-sync and permanently delete:");
     ui.log.warn(`  ${home}`);
-    ui.log.warn("(your login session, and every project's sync progress and agent configuration)");
+    ui.log.warn("  (your login session, and every project's sync progress and agent configuration)");
+    if (globalInstall)
+        ui.log.warn(`  the ${PACKAGE_NAME} CLI itself (npm uninstall -g ${PACKAGE_NAME})`);
+    ui.log.info("Your projects and their history in the cloud are not affected.");
     const confirmed = await confirmFn("Are you sure you want to uninstall resumecontext? This cannot be undone.");
     if (!confirmed) {
         ui.outro("Cancelled -- nothing was removed.");
         return { uninstalled: false };
     }
+    // Unregister first so no new tick starts, then end one already running,
+    // so nothing recreates the directory after it is deleted.
     uninstallService();
+    await stopTick();
     fs.rmSync(home, { recursive: true, force: true });
-    ui.outro("Uninstalled. Run `resumecontext auth` any time to start fresh.");
+    ui.log.success("Stopped auto-sync and deleted local state.");
+    if (markers.length > 0) {
+        ui.log.info(`Left in place, because they may be committed and shared with teammates (delete them if you don't want them):\n` +
+            markers.map((m) => `  ${m}`).join("\n"));
+    }
+    if (!globalInstall) {
+        ui.outro(`Uninstalled. Remove the CLI itself with the tool you installed it with, e.g. \`npm uninstall -g ${PACKAGE_NAME}\`.`);
+        return { uninstalled: true };
+    }
+    try {
+        await ui.withSpinner("Removing the CLI", "Removed the CLI.", async () => removePackage());
+    }
+    catch {
+        ui.log.warn(`Couldn't remove the CLI package. Run \`npm uninstall -g ${PACKAGE_NAME}\` yourself (it may need sudo).`);
+        ui.outro("Uninstalled, except for the CLI package.");
+        return { uninstalled: true };
+    }
+    ui.outro("Uninstalled resumecontext from this machine.");
     return { uninstalled: true };
 }

package/dist/daemon.js

@@ -42,13 +42,15 @@
  */
 import fs from "node:fs";
 import path from "node:path";
+import { execFileSync } from "node:child_process";
 import { agentConfigFile, daemonRegistryFile, daemonLogFile, daemonLockFile, daemonFingerprintCacheFile, syncStateFile, } from "./paths.js";
 import { apiErrorStatus } from "./apiClient.js";
 import { readAgentConfig } from "./agentConfig.js";
 import { readCredentials } from "./session.js";
 import { scanForNewTurns, pushNewTurns } from "./syncCore.js";
 import { MAX_LOG_BYTES } from "./constants.js";
-import { installPersistentService } from "./daemonService.js";
+import { DAEMON_SUBCOMMAND, detectPlatform, installPersistentService } from "./daemonService.js";
+import { installLocation } from "./packageInstall.js";
 import { fingerprintDirsForConfig } from "./localHistory/registry.js";
 import { findProjectRoot } from "./projectRoot.js";
 export function readRegistry() {
@@ -109,11 +111,18 @@ export function deregisterProject(projectId) {
  * anything, so callers can tell the user when auto-sync isn't available
  * here at all.
  *
+ * Never registers from a temporary runner cache (`npx` and friends, see
+ * installLocation): the service would point at files the package manager
+ * can delete at any time, and auto-sync would then fail silently every
+ * tick. `location` is returned so callers can tell the user why.
+ *
  * `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) {
-    return installService();
+export function ensureDaemonRunning(installService = installPersistentService, location = installLocation()) {
+    if (location === "temporary")
+        return { platform: detectPlatform(), installed: false, location };
+    return { ...installService(), location };
 }
 // ---- log rotation -------------------------------------------------------
 /** Keeps daemonLogFile() bounded, retaining one previous generation.
@@ -201,6 +210,67 @@ export function releaseLock(fsImpl = fs, pid = process.pid, lockPath = daemonLoc
         // already gone, or unreadable -- nothing more to do
     }
 }
+const realTickProcessControl = {
+    isAlive: isProcessAlive,
+    commandLine(pid) {
+        try {
+            const out = execFileSync("ps", ["-p", String(pid), "-o", "command="], {
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "ignore"],
+            });
+            return out.trim() || null;
+        }
+        catch {
+            return null;
+        }
+    },
+    signal(pid, signal) {
+        try {
+            process.kill(pid, signal);
+        }
+        catch {
+            // already gone
+        }
+    },
+};
+/** Ends the tick that holds the lock right now, if there is one. Used by
+ * uninstall: unregistering the schedule stops FUTURE ticks, but a tick
+ * already mid-scan would otherwise carry on and recreate sync state, the
+ * log and the lock inside a home directory uninstall just deleted.
+ *
+ * The lock only records a pid, and pids get reused, so the process is
+ * signalled only if its command line is still a daemon tick. SIGTERM
+ * first; SIGKILL if it hasn't exited by `timeoutMs`. Every push is
+ * idempotent on the server, so cutting one short loses nothing. Returns
+ * whether a running tick was found. */
+export async function stopRunningTick(control = realTickProcessControl, lockPath = daemonLockFile(), timeoutMs = 5_000) {
+    let pid;
+    try {
+        pid = Number(fs.readFileSync(lockPath, "utf8"));
+    }
+    catch {
+        return false; // no lock: nothing is running
+    }
+    if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid)
+        return false;
+    if (!control.isAlive(pid))
+        return false;
+    if (!control.commandLine(pid)?.includes(DAEMON_SUBCOMMAND))
+        return false;
+    const waitForExit = async (ms) => {
+        const deadline = Date.now() + ms;
+        while (control.isAlive(pid) && Date.now() < deadline) {
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+    };
+    control.signal(pid, "SIGTERM");
+    await waitForExit(timeoutMs);
+    if (control.isAlive(pid)) {
+        control.signal(pid, "SIGKILL");
+        await waitForExit(1_000);
+    }
+    return true;
+}
 // ---- change detection -----------------------------------------------------
 /** SQLite's WAL-mode sidecar files -- `<db>-shm` (shared memory index) and
  * `<db>-wal` (write-ahead log). Excluded from the fingerprint below: opening

package/dist/daemonNotices.js

@@ -0,0 +1,18 @@
+import * as ui from "./ui.js";
+export function printDaemonNotice(result) {
+    if (result.location === "temporary") {
+        ui.log.warn("Auto-sync is not set up: this CLI is running from a temporary download (npx) that can be deleted at any time.\n" +
+            "Install it with `npm install -g resumecontext` to sync in the background. `resumecontext sync` still works.");
+        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;
+    }
+    // Only when (re)registered, which is the first run and after an update --
+    // not on every command.
+    if (result.location === "folder" && result.installed) {
+        ui.log.warn("Auto-sync is running from this folder's node_modules and stops working if that folder or its node_modules is removed.\n" +
+            "Install globally with `npm install -g resumecontext` so it doesn't depend on a folder.");
+    }
+}

package/dist/daemonService.js

@@ -166,6 +166,9 @@ ${envBlock}  <key>RunAtLoad</key>
         statusCommand: ["launchctl", "list", LAUNCHD_LABEL],
         installCommands: [["launchctl", "load", "-w", plistPath]],
         uninstallCommands: [["launchctl", "unload", "-w", plistPath]],
+        // `launchctl unload` already sends SIGTERM to a tick that is running.
+        stopRunningCommands: [],
+        afterRemoveCommands: [],
     };
 }
 /** Same `version` parameter and reasoning as buildLaunchdPlan above. */
@@ -219,6 +222,9 @@ WantedBy=timers.target
             ["systemctl", "--user", "enable", "--now", SYSTEMD_TIMER_UNIT],
         ],
         uninstallCommands: [["systemctl", "--user", "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"]],
     };
 }
 export function buildPlan(platform, homeDir, version) {
@@ -307,12 +313,12 @@ export function uninstallPersistentService(execImpl = defaultExec, homeDir, fsIm
     if (!plan)
         return { platform, uninstalled: false };
     const wasActive = isServiceActive(execImpl, homeDir);
-    for (const [cmd, ...args] of plan.uninstallCommands) {
+    for (const [cmd, ...args] of [...plan.uninstallCommands, ...plan.stopRunningCommands]) {
         try {
             execImpl(cmd, args);
         }
         catch {
-            // not currently loaded/enabled -- nothing to unload
+            // not currently loaded/enabled/running -- nothing to stop
         }
     }
     let removedFiles = false;
@@ -322,5 +328,15 @@ export function uninstallPersistentService(execImpl = defaultExec, homeDir, fsIm
             removedFiles = true;
         }
     }
+    if (removedFiles) {
+        for (const [cmd, ...args] of plan.afterRemoveCommands) {
+            try {
+                execImpl(cmd, args);
+            }
+            catch {
+                // best effort -- the files are already gone
+            }
+        }
+    }
     return { platform, uninstalled: wasActive || removedFiles };
 }

package/dist/index.js

@@ -126,7 +126,7 @@ projectsCmd
     .action(withErrorHandling((projectId) => runProjectsDelete(deps(), projectId)));
 program
     .command("uninstall")
-    .description("stop auto-sync and delete all local resumecontext state (asks to confirm)")
+    .description("remove the CLI, its auto-sync and all local state from this machine (asks to confirm)")
     .action(withErrorHandling(() => runUninstall()));
 // Hidden: not something a user runs directly. This is the entry point the
 // OS scheduler invokes for EVERY tick -- the launchd plist's

package/dist/packageInstall.js

@@ -0,0 +1,87 @@
+/**
+ * How this CLI itself was installed, so `uninstall` can remove the package
+ * as well as its state.
+ *
+ * Only a global npm install is removed automatically: the running script has
+ * to live inside what `npm root -g` holds for this package (for an `npm link`
+ * that is the link, and uninstalling removes only the link). Anything else --
+ * a dev checkout under tsx, npx's cache, another package manager -- is left
+ * alone, because `npm uninstall -g` there would do nothing or remove
+ * something this process isn't.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+export const PACKAGE_NAME = "resumecontext";
+function defaultRun(command, args) {
+    return execFileSync(command, args, {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+        // npm is npm.cmd on Windows, which execFile can't start without a shell.
+        shell: process.platform === "win32",
+    });
+}
+function realpathOrNull(p) {
+    try {
+        return fs.realpathSync(p);
+    }
+    catch {
+        return null;
+    }
+}
+/** True if the running CLI is the copy installed by `npm install -g`. */
+export function isGlobalNpmInstall(run = defaultRun, entry = process.argv[1]) {
+    if (!entry)
+        return false;
+    const script = realpathOrNull(entry);
+    if (!script)
+        return false;
+    let root;
+    try {
+        root = run("npm", ["root", "-g"]).trim();
+    }
+    catch {
+        return false; // no npm on PATH
+    }
+    const packageDir = realpathOrNull(path.join(root, PACKAGE_NAME));
+    if (packageDir !== null && script.startsWith(packageDir + path.sep))
+        return true;
+    // npm masks anything in its output that looks like a secret, including a
+    // UUID-shaped directory name ("/Users/me/***/lib/node_modules"), which no
+    // longer exists on disk. Match the masked root against where the running
+    // package actually sits, with each `***` standing for one path segment.
+    if (!root.includes("***"))
+        return false;
+    // The part before the first mask does exist, so resolve its symlinks the
+    // way the script's path was resolved (macOS: /var -> /private/var).
+    const [head, ...rest] = path.join(root, PACKAGE_NAME).split("***");
+    const headDir = realpathOrNull(path.dirname(head + "x"));
+    if (headDir === null)
+        return false;
+    const parts = [headDir + head.slice(path.dirname(head + "x").length), ...rest];
+    const pattern = new RegExp("^" + parts.map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("[^/\\\\]+") + "$");
+    for (let dir = path.dirname(script); dir !== path.dirname(dir); dir = path.dirname(dir)) {
+        if (path.basename(dir) === PACKAGE_NAME)
+            return pattern.test(dir);
+    }
+    return false;
+}
+/** `npm uninstall -g resumecontext`. Throws if npm fails (most often a
+ * global prefix that needs sudo). Safe while this process is running: every
+ * module is already loaded. */
+export function removeGlobalNpmPackage(run = defaultRun) {
+    run("npm", ["uninstall", "-g", PACKAGE_NAME]);
+}
+export function installLocation(entry = process.argv[1]) {
+    if (!entry)
+        return "other";
+    const paths = [entry, realpathOrNull(entry) ?? entry].map((p) => p.split(path.sep).join("/"));
+    if (paths.some((p) => /\/_npx\/|\/dlx[-/]|\/bunx-/.test(p)))
+        return "temporary";
+    // A folder install's bin is always node_modules/.bin (npm, yarn, bun);
+    // pnpm's bin script instead runs the real file inside node_modules/.pnpm.
+    // Global installs use neither.
+    if (paths.some((p) => p.includes("/node_modules/.bin/") || p.includes("/node_modules/.pnpm/")))
+        return "folder";
+    return "other";
+}

package/package.json

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