resumecontext 0.1.0

package/dist/daemonService.js

@@ -0,0 +1,326 @@
+/**
+ * Registers auto-sync as a real OS-scheduled mechanism -- launchd
+ * StartInterval on macOS, a systemd --user timer on Linux -- so it survives
+ * a reboot and keeps firing on schedule, rather than being just a detached
+ * subprocess that a `kill -9`, a log-out, or a restart silently ends for
+ * good.
+ *
+ * Each platform's mechanism triggers a fresh, short-lived process per tick
+ * (daemon.ts's runDaemonTick) instead of supervising one long-running
+ * process -- see daemon.ts's module doc comment for why that's the design.
+ * launchd does this natively via StartInterval (RunAtLoad fires the first
+ * tick immediately, StartInterval fires every one after). systemd has no
+ * exact equivalent on the service unit itself, so Linux uses a `.timer`
+ * unit (the schedule) paired with a `Type=oneshot` `.service` unit (the
+ * work) -- the timer is what gets enabled/started; the service is what the
+ * timer activates each time. Both platforms end up with the identical
+ * shape from daemon.ts's point of view: something re-invokes this CLI with
+ * the hidden `__daemon-run` subcommand every DAEMON_INTERVAL_MS.
+ *
+ * Every OS-touching function here is split into a pure "build the plan"
+ * half (the config file contents and the commands to run, computed with no
+ * I/O) and a thin "apply it" half that actually writes files and runs
+ * commands -- with fs/exec injectable on the apply half specifically so
+ * tests can verify the exact plan produced without ever writing to a real
+ * user's ~/Library/LaunchAgents or ~/.config/systemd, or running a real
+ * launchctl/systemctl command. Nothing in this file's test suite is
+ * permitted to touch the real OS service manager -- see daemonService.test.ts.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import crypto from "node:crypto";
+import { DAEMON_INTERVAL_MS } from "./constants.js";
+import { daemonLogFile } from "./paths.js";
+import { cliVersion } from "./version.js";
+export const DAEMON_SUBCOMMAND = "__daemon-run";
+const DAEMON_INTERVAL_SECONDS = DAEMON_INTERVAL_MS / 1000;
+/** Re-invokes this exact process as one daemon tick: same interpreter,
+ * same loader flags (tsx's --require/--import hooks in dev, none once this
+ * is the compiled dist/index.js), same entry script, plus the hidden
+ * daemon subcommand -- so both the launchd/systemd plans below agree on
+ * exactly how to relaunch themselves. */
+export function daemonProgramArguments() {
+    return [process.execPath, ...process.execArgv, process.argv[1], DAEMON_SUBCOMMAND];
+}
+/**
+ * The environment overrides the service has to carry.
+ *
+ * Neither launchd nor systemd inherits the shell that installed the service,
+ * so without this a daemon registered by a CLI pointed at a local or staging
+ * backend would wake up pointed at production, and push that project's
+ * sessions there. These two are the only variables that change which backend
+ * is talked to and which credentials are used, so they are the only two worth
+ * baking in.
+ *
+ * Empty for an ordinary install, which is the point: the service file for
+ * someone who has never set either of these is byte-for-byte what it always
+ * was. And because installPersistentService compares file contents, switching
+ * between backends rewrites the file and forces a reinstall rather than
+ * leaving a daemon quietly pointed at the old one.
+ */
+export function daemonEnvironment() {
+    const env = {};
+    for (const key of ["RESUMECONTEXT_API_URL", "RESUMECONTEXT_HOME"]) {
+        const value = process.env[key];
+        if (value)
+            env[key] = value;
+    }
+    return env;
+}
+/**
+ * The launchd label and systemd unit names for THIS configuration.
+ *
+ * An ordinary install gets the plain names. A CLI running with either override
+ * (the dev CLI, pointed at a local backend with its own state directory) gets
+ * names suffixed with a hash of those overrides. Sharing one name meant signing
+ * in with the dev CLI rewrote the real CLI's service file -- pointing the real
+ * daemon at localhost and a different state directory, so real projects
+ * stopped syncing until the real CLI happened to reinstall it, which in turn
+ * silently unregistered the dev one.
+ */
+export function serviceNames() {
+    const env = daemonEnvironment();
+    const suffix = Object.keys(env).length === 0
+        ? ""
+        : `-${crypto.createHash("sha256").update(JSON.stringify(Object.entries(env).sort())).digest("hex").slice(0, 8)}`;
+    return {
+        launchdLabel: `com.resumecontext.daemon${suffix.replace("-", ".")}`,
+        systemdService: `resumecontext-daemon${suffix}.service`,
+        systemdTimer: `resumecontext-daemon${suffix}.timer`,
+    };
+}
+export function detectPlatform() {
+    if (process.platform === "darwin")
+        return "launchd";
+    if (process.platform === "linux")
+        return "systemd";
+    return "unsupported";
+}
+function xmlEscape(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+/** `homeDir` defaults to the real home directory but is a parameter (not
+ * baked in) specifically so tests can point every path this produces at a
+ * scratch directory, as a second line of defense on top of fs injection --
+ * even a test that slipped and used the real fs would land somewhere
+ * harmless.
+ *
+ * `version` defaults to cliVersion() but is likewise a parameter so tests
+ * can pin it -- it's embedded below purely as a comment so that a version
+ * bump changes the file's contents even when daemonProgramArguments()
+ * doesn't (an in-place reinstall at the same path, e.g. `npm install -g`
+ * over an existing global install). installPersistentService's staleness
+ * check is a plain string comparison of every file's contents, so this is
+ * enough to make every version bump force a reinstall -- see that
+ * function's doc comment. */
+export function buildLaunchdPlan(homeDir = os.homedir(), version = cliVersion()) {
+    const args = daemonProgramArguments();
+    const logFile = daemonLogFile();
+    const { launchdLabel: LAUNCHD_LABEL } = serviceNames();
+    const plistPath = path.join(homeDir, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+    const env = daemonEnvironment();
+    const envBlock = Object.keys(env).length === 0
+        ? ""
+        : `  <key>EnvironmentVariables</key>
+  <dict>
+${Object.entries(env)
+            .map(([k, v]) => `    <key>${xmlEscape(k)}</key>\n    <string>${xmlEscape(v)}</string>`)
+            .join("\n")}
+  </dict>
+`;
+    const contents = `<?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">
+<!-- resumecontext-cli-version: ${xmlEscape(version)} -->
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args.map((a) => `    <string>${xmlEscape(a)}</string>`).join("\n")}
+  </array>
+${envBlock}  <key>RunAtLoad</key>
+  <true/>
+  <key>StartInterval</key>
+  <integer>${DAEMON_INTERVAL_SECONDS}</integer>
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(logFile)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(logFile)}</string>
+</dict>
+</plist>
+`;
+    return {
+        files: [{ path: plistPath, contents }],
+        // `launchctl list <label>` exits non-zero when the label isn't loaded.
+        // Deliberately NOT KeepAlive: that restarts the process the instant it
+        // exits, which for a one-shot tick means immediately, fighting
+        // StartInterval instead of waiting for it. launchd's own singleton
+        // behavior per label already means it won't start a second instance
+        // of this label while StartInterval's previous invocation is still
+        // running (daemon.ts's file lock is the belt-and-suspenders backstop
+        // for that, portable to systemd where the same guarantee is less
+        // absolute).
+        statusCommand: ["launchctl", "list", LAUNCHD_LABEL],
+        installCommands: [["launchctl", "load", "-w", plistPath]],
+        uninstallCommands: [["launchctl", "unload", "-w", plistPath]],
+    };
+}
+/** Same `version` parameter and reasoning as buildLaunchdPlan above. */
+export function buildSystemdPlan(homeDir = os.homedir(), version = cliVersion()) {
+    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 quote = (s) => (/\s/.test(s) ? `"${s.replace(/"/g, '\\"')}"` : s);
+    const envLines = Object.entries(daemonEnvironment())
+        .map(([k, v]) => `Environment=${k}=${quote(v)}\n`)
+        .join("");
+    const serviceContents = `# resumecontext-cli-version: ${version}
+[Unit]
+Description=resumecontext auto-sync (one tick)
+
+[Service]
+Type=oneshot
+${envLines}ExecStart=${args.map(quote).join(" ")}
+StandardOutput=append:${logFile}
+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.
+    const timerContents = `[Unit]
+Description=resumecontext auto-sync timer
+
+[Timer]
+OnBootSec=0
+OnUnitActiveSec=${DAEMON_INTERVAL_SECONDS}s
+Unit=${SYSTEMD_SERVICE_UNIT}
+
+[Install]
+WantedBy=timers.target
+`;
+    return {
+        files: [
+            { path: servicePath, contents: serviceContents },
+            { path: timerPath, contents: timerContents },
+        ],
+        // Checks the TIMER, not the oneshot service -- see ServicePlan's doc.
+        statusCommand: ["systemctl", "--user", "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],
+        ],
+        uninstallCommands: [["systemctl", "--user", "disable", "--now", SYSTEMD_TIMER_UNIT]],
+    };
+}
+export function buildPlan(platform, homeDir, version) {
+    if (platform === "launchd")
+        return buildLaunchdPlan(homeDir, version);
+    if (platform === "systemd")
+        return buildSystemdPlan(homeDir, version);
+    return null;
+}
+function defaultExec(command, args) {
+    execFileSync(command, args, { stdio: "ignore" });
+}
+/** True if `plan`'s schedule is already registered/active. */
+export function isServiceActive(execImpl = defaultExec, homeDir) {
+    const plan = buildPlan(detectPlatform(), homeDir);
+    if (!plan)
+        return false;
+    try {
+        execImpl(plan.statusCommand[0], plan.statusCommand.slice(1));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function readFileIfPresent(fsImpl, filePath) {
+    try {
+        return fsImpl.readFileSync(filePath, "utf8");
+    }
+    catch {
+        return null; // never installed, or the file was removed out from under us
+    }
+}
+/** True only if EVERY file in the plan is present on disk with exactly
+ * the contents we'd write today -- systemd's plan is two files (service +
+ * timer), and either one being stale is enough to warrant reinstalling
+ * both, since they're only ever meaningful as a pair. */
+function planUpToDate(fsImpl, plan) {
+    return plan.files.every((f) => readFileIfPresent(fsImpl, f.path) === f.contents);
+}
+export function installPersistentService(fsImpl = fs, execImpl = defaultExec, homeDir) {
+    const platform = detectPlatform();
+    const plan = buildPlan(platform, homeDir);
+    if (!plan)
+        return { platform, installed: false };
+    // "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:
+    //  - the launch path changed: daemonProgramArguments() bakes in
+    //    process.execPath/argv[1], so a new versioned install path, a moved
+    //    checkout, or a first run under `tsx` followed by a real install
+    //    leave the schedule pointing somewhere stale.
+    //  - an in-place upgrade at the SAME path (e.g. `npm install -g` over an
+    //    existing global install): the launch path doesn't change, but the
+    //    code on disk did. buildLaunchdPlan/buildSystemdPlan embed
+    //    cliVersion() as a comment specifically so this case also shows up
+    //    as a content difference.
+    // Either way: compare every on-disk file against what we'd write now,
+    // and treat any difference as "must reinstall".
+    if (planUpToDate(fsImpl, plan) && isServiceActive(execImpl, homeDir))
+        return { platform, installed: false };
+    for (const file of plan.files) {
+        fsImpl.mkdirSync(path.dirname(file.path), { recursive: true });
+        fsImpl.writeFileSync(file.path, file.contents);
+    }
+    // Unload the stale definition before loading the new one -- `launchctl
+    // load` on an already-loaded label is an error, and a stale systemd
+    // timer would otherwise keep firing the OLD service definition until
+    // restarted. Failure here is expected and ignored: it just means
+    // nothing was loaded to begin with.
+    for (const [cmd, ...args] of plan.uninstallCommands) {
+        try {
+            execImpl(cmd, args);
+        }
+        catch {
+            // not currently loaded -- nothing to unload
+        }
+    }
+    for (const [cmd, ...args] of plan.installCommands)
+        execImpl(cmd, args);
+    return { platform, installed: true };
+}
+export function uninstallPersistentService(execImpl = defaultExec, homeDir, fsImpl = fs) {
+    const platform = detectPlatform();
+    const plan = buildPlan(platform, homeDir);
+    if (!plan)
+        return { platform, uninstalled: false };
+    const wasActive = isServiceActive(execImpl, homeDir);
+    for (const [cmd, ...args] of plan.uninstallCommands) {
+        try {
+            execImpl(cmd, args);
+        }
+        catch {
+            // not currently loaded/enabled -- nothing to unload
+        }
+    }
+    let removedFiles = false;
+    for (const file of plan.files) {
+        if (fsImpl.existsSync(file.path)) {
+            fsImpl.unlinkSync(file.path);
+            removedFiles = true;
+        }
+    }
+    return { platform, uninstalled: wasActive || removedFiles };
+}

package/dist/deps.js

@@ -0,0 +1 @@
+export {};

package/dist/dev.js

@@ -0,0 +1,32 @@
+/**
+ * `npm run dev` -- the CLI pointed at a backend running on this machine.
+ *
+ * Two overrides, both of which the CLI already honours; this file only
+ * supplies dev defaults for them so nobody has to remember the incantation:
+ *
+ *   RESUMECONTEXT_API_URL   the backend. `npm run dev` in ../backend listens
+ *                           on 3001, and that backend's own API_URL and
+ *                           WEBSITE_URL point at localhost, so the sign-in URL
+ *                           and the MCP endpoint it hands back are local too.
+ *                           Nothing else needs configuring.
+ *
+ *   RESUMECONTEXT_HOME      local state. Pointed at a separate directory so a
+ *                           dev sign-in does not overwrite the credentials and
+ *                           device id of the real CLI, whose tokens are issued
+ *                           by a different backend and would be rejected by it.
+ *
+ * Both are only defaults: setting either in the environment wins, so this
+ * still works for pointing at a staging backend or sharing the real home.
+ *
+ * The daemon is handled too. daemonProgramArguments() bakes `process.argv[1]`
+ * into the service file, which for this entrypoint is this file -- so a daemon
+ * registered by the dev CLI re-enters here on every tick and picks the same
+ * two defaults back up. It also gets them written into the service file
+ * explicitly (see daemonService.ts), because an exported variable is not
+ * inherited by launchd or systemd.
+ */
+import path from "node:path";
+import os from "node:os";
+process.env.RESUMECONTEXT_API_URL ||= "http://localhost:3001";
+process.env.RESUMECONTEXT_HOME ||= path.join(os.homedir(), ".resumecontext-dev");
+await import("./index.js");

package/dist/device.js

@@ -0,0 +1,40 @@
+/**
+ * This machine's identity.
+ *
+ * A bare UUID, generated once and kept in the CLI's home directory rather than
+ * in any project: it identifies the MACHINE, and the same machine syncs many
+ * projects. There is deliberately no human-readable name -- a hostname would
+ * be shared with everyone on a project without anyone choosing to share it,
+ * and nothing in the product needs to display one. The id only ever has to
+ * answer "same machine or not".
+ *
+ * It is sent once, when starting a device sign-in, and the backend binds it
+ * into the issued token. Every later push and MCP call is then attributable to
+ * this machine without the CLI sending anything further, and without a client
+ * being able to claim a machine that is not its own.
+ */
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { deviceFile } from "./paths.js";
+/** The server rejects anything that is not a UUID, so a stored value that no
+ * longer looks like one is treated as corrupt and replaced -- otherwise a
+ * machine whose device.json got mangled could never sign in again. */
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function deviceId() {
+    const file = deviceFile();
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, "utf-8"));
+        if (typeof parsed?.id === "string" && UUID_RE.test(parsed.id))
+            return parsed.id;
+    }
+    catch {
+        // Missing or corrupt -- fall through and mint a new one. A machine that
+        // loses its id looks like a new machine, which is a harmless degradation:
+        // older sessions read as "another machine of yours" rather than "here".
+    }
+    const id = crypto.randomUUID();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify({ id }, null, 2));
+    return id;
+}

package/dist/httpCloudApi.js

@@ -0,0 +1,61 @@
+/**
+ * The real CloudApi implementation -- every method is one axios call
+ * through the shared apiClient (see apiClient.ts), which is also where all
+ * 401 handling lives. Every command already goes through this same
+ * interface, so nothing above this file needs to know or care that it's
+ * now backed by real HTTP instead of an in-process fake.
+ */
+import { apiClient } from "./apiClient.js";
+import { deviceId } from "./device.js";
+import { API_VERSION } from "./constants.js";
+function bearer(token) {
+    return { headers: { Authorization: `Bearer ${token}` } };
+}
+export class HttpCloudApi {
+    async startDeviceLogin() {
+        // The machine id goes in at the START of the flow, so whichever way the
+        // browser finishes it -- a fresh Google sign-in, or an existing web
+        // session -- the token that comes back is bound to this machine.
+        const { data } = await apiClient.post("/auth/device/start", {
+            deviceId: deviceId(),
+        });
+        return data;
+    }
+    async pollDeviceLogin(deviceCode) {
+        const { data } = await apiClient.get(`/auth/device/poll/${deviceCode}`);
+        return data;
+    }
+    async createProject(token, label) {
+        const { data } = await apiClient.post(`/${API_VERSION}/projects`, { label }, bearer(token));
+        return data;
+    }
+    async findProject(token, projectId) {
+        const { data } = await apiClient.get(`/${API_VERSION}/projects/${projectId}`, bearer(token));
+        return data;
+    }
+    async pushTurns(token, projectId, turns) {
+        const { data } = await apiClient.post(`/${API_VERSION}/projects/${projectId}/turns`, { turns }, bearer(token));
+        return data;
+    }
+    async shareProject(token, projectId, email) {
+        await apiClient.post(`/${API_VERSION}/projects/${projectId}/members`, { email }, bearer(token));
+    }
+    async acceptInvite(token, projectId) {
+        const { data } = await apiClient.post(`/${API_VERSION}/projects/${projectId}/accept`, {}, bearer(token));
+        return data;
+    }
+    async revokeAccess(token, projectId, email) {
+        await apiClient.delete(`/${API_VERSION}/projects/${projectId}/members/${encodeURIComponent(email)}`, bearer(token));
+    }
+    async listMembers(token, projectId) {
+        const { data } = await apiClient.get(`/${API_VERSION}/projects/${projectId}/members`, bearer(token));
+        return data.members;
+    }
+    async listProjects(token) {
+        const { data } = await apiClient.get(`/${API_VERSION}/projects`, bearer(token));
+        return data.projects;
+    }
+    async deleteProject(token, projectId) {
+        await apiClient.delete(`/${API_VERSION}/projects/${projectId}`, bearer(token));
+    }
+}

package/dist/index.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+/**
+ * Commander wiring: routes CLI args to the pure command functions in
+ * commands/*.ts, injecting the real Deps (HttpCloudApi -- real HTTP via the
+ * shared axios client against api.resumecontext.com, and
+ * RealLocalCapture reading each agent's own local history via
+ * localHistory/). This is the ONLY file that
+ * constructs real dependencies or touches process.exit for error handling
+ * -- every command function itself just throws a plain Error with a
+ * user-facing message and returns.
+ */
+import { Command } from "commander";
+import chalk from "chalk";
+import { HttpCloudApi } from "./httpCloudApi.js";
+import { RealLocalCapture } from "./localCapture.js";
+import { ensureAgentConfigWithDaemon } from "./agentConfigWithDaemon.js";
+import { runDaemonTick } from "./daemon.js";
+import { DAEMON_SUBCOMMAND } from "./daemonService.js";
+import { cliVersion } from "./version.js";
+import * as ui from "./ui.js";
+import { runAuth } from "./commands/auth.js";
+import { runInit } from "./commands/init.js";
+import { runSync } from "./commands/sync.js";
+import { runShare } from "./commands/share.js";
+import { runAccept } from "./commands/accept.js";
+import { runRevoke } from "./commands/revoke.js";
+import { runMembers } from "./commands/members.js";
+import { runMcp } from "./commands/mcp.js";
+import { runAgents } from "./commands/agents.js";
+import { runLogout } from "./commands/logout.js";
+import { runDaemonStatus, runDaemonStart, runDaemonStop } from "./commands/daemon.js";
+import { runProjectsList, runProjectsDelete } from "./commands/projects.js";
+import { runUninstall } from "./commands/uninstall.js";
+const cloudApi = new HttpCloudApi();
+const localCapture = new RealLocalCapture();
+function deps() {
+    return { cloudApi, cwd: process.cwd(), ensureAgentConfig: ensureAgentConfigWithDaemon };
+}
+function syncDeps() {
+    return { ...deps(), localCapture };
+}
+function withErrorHandling(action) {
+    return async (...args) => {
+        try {
+            await action(...args);
+        }
+        catch (err) {
+            ui.printError(err);
+            if (program.opts().debug && err instanceof Error && err.stack) {
+                console.error(chalk.dim(err.stack));
+            }
+            process.exitCode = 1;
+        }
+    };
+}
+const program = new Command();
+program
+    .name("resumecontext")
+    .description("Shared context for coding agents -- resumecontext.com")
+    .version(cliVersion())
+    .option("--debug", "show full stack traces on unexpected errors");
+program
+    .command("auth")
+    .description("log in to resumecontext.com (opens your browser)")
+    .action(withErrorHandling(() => runAuth(deps())));
+program
+    .command("logout")
+    .description("clear this machine's stored session")
+    .action(withErrorHandling(() => runLogout()));
+program
+    .command("init")
+    .description("connect this directory to a resumecontext project")
+    .action(withErrorHandling(() => runInit(deps())));
+program
+    .command("sync")
+    .description("push local coding-agent history for this project")
+    .action(withErrorHandling(() => runSync(syncDeps())));
+program
+    .command("share")
+    .description("invite someone to this project (owner only)")
+    .argument("<email>", "email address to invite")
+    .action(withErrorHandling((email) => runShare(deps(), email)));
+program
+    .command("accept")
+    .description("accept a pending invite for this project")
+    .action(withErrorHandling(() => runAccept(deps())));
+program
+    .command("revoke")
+    .description("remove someone's access to this project (owner only)")
+    .argument("<email>", "email address to remove")
+    .action(withErrorHandling((email) => runRevoke(deps(), email)));
+program
+    .command("members")
+    .description("list everyone with access to this project (owner only)")
+    .action(withErrorHandling(() => runMembers(deps())));
+program
+    .command("mcp")
+    .description("show the MCP URL and token for configuring your coding agent")
+    .action(withErrorHandling(() => runMcp(deps())));
+program
+    .command("agents")
+    .description("choose which coding agents to sync from, and where their data lives")
+    .action(withErrorHandling(() => runAgents(deps())));
+const daemonCmd = program.command("daemon").description("manage the background auto-sync service");
+daemonCmd
+    .command("status")
+    .description("show whether auto-sync is running")
+    .action(withErrorHandling(() => runDaemonStatus()));
+daemonCmd
+    .command("start")
+    .description("(re)enable auto-sync -- rarely needed, every project command does this on its own")
+    .action(withErrorHandling(() => runDaemonStart()));
+daemonCmd
+    .command("stop")
+    .description("stop auto-sync (restarts next time you run a project command like `sync`)")
+    .action(withErrorHandling(() => runDaemonStop()));
+const projectsCmd = program.command("projects").description("manage your resumecontext projects");
+projectsCmd
+    .command("list")
+    .description("list every project you own or have access to")
+    .action(withErrorHandling(() => runProjectsList(deps())));
+projectsCmd
+    .command("delete")
+    .description("permanently delete a project (owner only)")
+    .argument("<projectId>", "project id, from `resumecontext projects list`")
+    .action(withErrorHandling((projectId) => runProjectsDelete(deps(), projectId)));
+program
+    .command("uninstall")
+    .description("stop auto-sync and delete all local resumecontext state (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
+// ProgramArguments (StartInterval) and the systemd timer's triggered
+// oneshot service (ExecStart) both re-invoke this same binary with this
+// subcommand every DAEMON_INTERVAL_MS (see daemonProgramArguments in
+// daemonService.ts). Each invocation is a fresh process that runs one tick
+// and exits -- see daemon.ts's module doc comment for why that's the
+// design (self-healing from a hung/crashed tick) rather than one
+// persistent process looping forever.
+//
+// Explicitly calls process.exit() rather than letting the process exit
+// naturally once the event loop empties: an open keep-alive HTTP
+// connection to the cloud API (or anything else holding a handle open)
+// would otherwise leave the process alive indefinitely, and since it
+// still holds daemon.ts's lock file while alive, that would silently wedge
+// every future tick forever -- the exact failure mode this redesign
+// exists to eliminate. Bypasses withErrorHandling for the same reason
+// runDaemonLoop used to: that wrapper prints to the terminal and sets
+// process.exitCode for an interactive command, neither of which means
+// anything for a background process with no terminal.
+program
+    .command(DAEMON_SUBCOMMAND, { hidden: true })
+    .action(() => runDaemonTick(cloudApi, localCapture).then(() => process.exit(0), (err) => {
+    console.error(err);
+    process.exit(1);
+}));
+async function main() {
+    await program.parseAsync(process.argv);
+}
+main();

package/dist/localCapture.js

@@ -0,0 +1,18 @@
+/**
+ * Behind the LocalCapture interface so command tests never need real local
+ * ~/.claude / ~/.cursor / etc. data on the machine running them -- they
+ * inject a fake that returns canned turns instead. The real implementation
+ * (RealLocalCapture) just calls localHistory/'s in-process parser --
+ * nothing here shells out to another package or reads another package's
+ * output files; this CLI owns its own local-history parsing end to end.
+ *
+ * Takes the agent config as an argument rather than reading it: the config
+ * is keyed by projectId (see agentConfig.ts), which this layer has no way
+ * to know from a project root alone. The caller already resolved it.
+ */
+import { collectLocalTurns } from "./localHistory/index.js";
+export class RealLocalCapture {
+    async scan(projectRoot, config) {
+        return collectLocalTurns(projectRoot, config);
+    }
+}