resumecontext 0.1.0

package/README.md

@@ -0,0 +1,27 @@
+# resumecontext
+
+Your coding agents forget. Your teammates' agents never knew.
+
+`resumecontext` records the sessions your coding agents already write to disk,
+syncs them to one archive per project, and hands that archive back to every
+agent through MCP. Your agent can then answer from what you and your team
+actually did: which approach was abandoned and why, what a teammate changed
+last week, where the work stopped when a usage limit hit.
+
+```bash
+npm install -g resumecontext
+
+resumecontext auth          # sign in, binding this machine
+cd ~/code/my-service
+resumecontext init          # this directory becomes the project
+resumecontext mcp           # the config block to paste into your agent
+```
+
+From then on it syncs on its own, roughly every twenty seconds. There is no
+sync command to remember and nothing to change about how you prompt.
+
+- **Docs:** https://resumecontext.com/docs
+- **Quickstart:** https://resumecontext.com/docs/quickstart
+- **Which agents are supported:** https://resumecontext.com/docs/cli/agents
+
+Requires Node 22 or newer.

package/dist/agentConfig.js

@@ -0,0 +1,202 @@
+/**
+ * Per-project configuration of which coding agents this CLI scans for local
+ * history, and where their data lives on disk. Never assumed to be the
+ * OS-default locations -- the user picks, once per project, and can change
+ * it later with `resumecontext agents`. Persisted (keyed by projectId, see
+ * paths.ts) so a first-time user is prompted exactly once per project,
+ * whichever project-scoped command they happen to run first -- see
+ * ensureAgentConfig, which every command in commands/*.ts calls after
+ * resolving its project, except auth/logout which have no project.
+ *
+ * Scoped per project rather than per machine because different projects
+ * legitimately draw on different agents: one repo's history might live
+ * entirely in Claude Code while another was worked on in Cursor, and
+ * scanning stores that were never used for a project is wasted work.
+ *
+ * Each agent gets a LIST of directories, not one: the same agent can keep
+ * history in more than one place (a non-standard install, another machine's
+ * data copied over, a data dir that moved whose older history still matters).
+ *
+ * Everything agent-specific -- labels, default locations, what a valid data
+ * directory looks like -- comes from localHistory/registry.ts, so this file
+ * works unchanged as more agents are supported.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import chalk from "chalk";
+import { agentConfigFile } from "./paths.js";
+import { resolveUserPath, unique } from "./utils.js";
+import * as ui from "./ui.js";
+import { AGENT_ADAPTERS, ALL_AGENT_NAMES } from "./localHistory/registry.js";
+export { ALL_AGENT_NAMES };
+/** Parses a config file's contents, ignoring anything that doesn't match
+ * the shape written by writeAgentConfig -- unknown agent names and entries
+ * without a `dirs` array are dropped rather than trusted, so a hand-edited
+ * or truncated file degrades to "configure this project again" instead of
+ * crashing a command or silently scanning nothing. */
+function parseConfig(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const rawAgents = raw.agents;
+    if (!rawAgents || typeof rawAgents !== "object")
+        return null;
+    const agents = {};
+    for (const [name, value] of Object.entries(rawAgents)) {
+        if (!ALL_AGENT_NAMES.includes(name))
+            continue;
+        const dirs = value?.dirs;
+        if (!Array.isArray(dirs))
+            continue;
+        agents[name] = { dirs: unique(dirs.filter((d) => typeof d === "string")) };
+    }
+    return { agents };
+}
+export function readAgentConfig(projectId) {
+    try {
+        return parseConfig(JSON.parse(fs.readFileSync(agentConfigFile(projectId), "utf-8")));
+    }
+    catch {
+        return null;
+    }
+}
+export function writeAgentConfig(projectId, config) {
+    const file = agentConfigFile(projectId);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(config, null, 2));
+}
+const ADD_ROW = "\0add";
+const NEXT_ROW = "\0next";
+/** Asks for one new directory, accepting it only if it actually looks like
+ * this agent's data directory -- an unrecognised path is refused outright
+ * rather than offered as an override, since silently syncing from a
+ * directory we can't parse would just fail later, further from the cause.
+ *
+ * A rejection re-prompts with what they typed still editable, so fixing a
+ * typo is immediate; submitting an empty line backs out to the directory
+ * list. Both paths out are stated in the prompt itself, so there are no
+ * yes/no questions in this flow. Returns null when they back out. */
+async function promptForNewDir(adapter, alreadyListed) {
+    let seed = "";
+    while (true) {
+        const answer = await ui.promptText(`Path to a ${adapter.label} data directory ${chalk.dim("(leave empty to go back)")}`, { initialValue: seed, placeholder: adapter.defaultDir });
+        if (!answer.trim())
+            return null;
+        const dir = resolveUserPath(answer);
+        if (alreadyListed.includes(dir)) {
+            ui.log.warn(`${dir} is already in the list.`);
+            seed = answer;
+            continue;
+        }
+        if (adapter.looksLikeDataDir(dir))
+            return dir;
+        ui.log.warn(`${dir} doesn't look like a ${adapter.label} data directory, so it can't be added.`);
+        ui.log.info(`Expected to find: ${adapter.expectedShape}`);
+        seed = answer; // keep it editable rather than making them retype
+    }
+}
+/** The directory screen for one agent: the paths currently configured for
+ * it, each showing whether it validates, plus buttons to add another and
+ * to move on. Rebuilt and re-prompted after every action so the list on
+ * screen always reflects the current state. */
+async function promptForAgentDirs(adapter, existing) {
+    // Seed with the usual location so the common case is just pressing Next,
+    // while still being a listed, removable entry rather than an assumption.
+    let dirs = unique(existing?.length ? existing : [adapter.defaultDir]);
+    let cursorAt;
+    while (true) {
+        const rows = dirs.map((dir) => ({
+            value: dir,
+            label: dir,
+            tone: "item",
+            hint: adapter.looksLikeDataDir(dir) ? chalk.green("✔ recognised") : chalk.yellow("⚠ not recognised"),
+            help: "enter to remove this path · ↑/↓ to move",
+        }));
+        if (dirs.length === 0) {
+            rows.push({ value: "\0empty", label: "(no directories yet)", tone: "warn", help: "add one below" });
+        }
+        rows.push({
+            value: ADD_ROW,
+            label: "+ Add another directory",
+            tone: "action",
+            separated: true,
+            help: "enter to add a directory",
+        });
+        rows.push({
+            value: NEXT_ROW,
+            label: dirs.length > 0 ? "→ Next" : "→ Next (nothing will be synced for this agent)",
+            tone: dirs.length > 0 ? "action" : "warn",
+            help: "enter to continue",
+        });
+        const choice = await ui.menu(`Where does ${adapter.label} store its data?`, rows, { cursorAt });
+        if (choice === NEXT_ROW)
+            return dirs;
+        if (choice === ADD_ROW) {
+            const added = await promptForNewDir(adapter, dirs);
+            if (added)
+                dirs.push(added);
+            cursorAt = ADD_ROW; // stay put so another add is one keypress away
+            continue;
+        }
+        if (choice === "\0empty") {
+            cursorAt = ADD_ROW;
+            continue;
+        }
+        // A path row: remove it. Reversible via Add, so no confirmation step.
+        dirs = dirs.filter((d) => d !== choice);
+        cursorAt = dirs.length > 0 ? undefined : ADD_ROW;
+    }
+}
+/** Interactively asks which agents to sync from and where their data lives,
+ * then persists the answer. EVERY supported agent is offered, but only the
+ * ones actually detected on this machine are pre-selected -- someone with
+ * just Claude Code and Codex shouldn't have to deselect the rest, while
+ * someone keeping Cursor's data somewhere non-standard can still select it
+ * and type the path. */
+export async function promptForAgentConfig(projectId, existing) {
+    const detected = ALL_AGENT_NAMES.filter((name) => AGENT_ADAPTERS[name].looksLikeDataDir(AGENT_ADAPTERS[name].defaultDir));
+    // Reconfiguring keeps the current selection; a first run falls back to
+    // whatever was detected locally.
+    const alreadyConfigured = existing ? Object.keys(existing.agents) : [];
+    const preselected = alreadyConfigured.length > 0 ? alreadyConfigured : detected;
+    const selected = (await ui.multiselect("Which coding agents should resumecontext sync from?", ALL_AGENT_NAMES.map((name) => ({
+        value: name,
+        label: AGENT_ADAPTERS[name].label,
+        hint: detected.includes(name) ? "found on this machine" : "not found in the usual place",
+    })), preselected));
+    const config = { agents: {} };
+    if (selected.length === 0) {
+        ui.log.warn("No agents selected -- `resumecontext sync` won't find anything to push.");
+        writeAgentConfig(projectId, config);
+        return config;
+    }
+    // Restate the choice in plain words before asking for paths -- the picker
+    // is transient, and this is the last chance to notice a mis-toggle before
+    // walking through directories for the wrong set of agents.
+    const skipped = ALL_AGENT_NAMES.filter((name) => !selected.includes(name));
+    ui.log.success(`Will sync: ${selected.map((n) => AGENT_ADAPTERS[n].label).join(", ")}`);
+    if (skipped.length > 0) {
+        ui.log.info(`Skipping: ${skipped.map((n) => AGENT_ADAPTERS[n].label).join(", ")}`);
+    }
+    for (const name of selected) {
+        const dirs = await promptForAgentDirs(AGENT_ADAPTERS[name], existing?.agents[name]?.dirs);
+        // An agent left with no directories is the same as not selecting it, so
+        // record it that way rather than storing a stub that scans nothing.
+        if (dirs.length === 0) {
+            ui.log.warn(`No directories set for ${AGENT_ADAPTERS[name].label} -- skipping it.`);
+            continue;
+        }
+        config.agents[name] = { dirs };
+    }
+    writeAgentConfig(projectId, config);
+    return config;
+}
+/** Called at the top of every project-scoped command: returns the existing
+ * config if the user has already set one up, or runs the interactive prompt
+ * once (and persists the result) if not. */
+export async function ensureAgentConfig(projectId) {
+    const existing = readAgentConfig(projectId);
+    if (existing)
+        return existing;
+    ui.log.warn("First time syncing this project -- let's set up which coding agents to sync from.");
+    return promptForAgentConfig(projectId);
+}

package/dist/agentConfigWithDaemon.js

@@ -0,0 +1,42 @@
+/**
+ * Composes agentConfig.ts's prompt-or-return with daemon registration --
+ * the single place "a project's agent config is settled (whether newly
+ * prompted or just already on disk)" gets wired to
+ * "the daemon should now cover it." Kept out of both agentConfig.ts and
+ * daemon.ts on purpose: agentConfig.ts stays with zero knowledge of
+ * daemons, daemon.ts stays with zero knowledge of the interactive setup
+ * flow, and daemon.ts already imports readAgentConfig from agentConfig.ts
+ * -- having agentConfig.ts import back from daemon.ts would make that a
+ * cycle.
+ *
+ * Scoped to exactly that: the project-scoped commands routed through
+ * Deps.ensureAgentConfig. `resumecontext agents` deliberately does NOT go
+ * through here -- it only edits config that a running daemon re-reads every
+ * tick anyway, so routing it through here would buy nothing and would
+ * silently restart a daemon the user explicitly stopped.
+ */
+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.");
+    }
+}
+/** 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
+ * the function wired into Deps.ensureAgentConfig (see index.ts).
+ *
+ * `ensureDaemonRunningFn` is injectable -- defaulting to the real
+ * ensureDaemonRunning, which registers a REAL OS service -- so tests can
+ * verify this composes registration correctly without ever touching the
+ * real launchctl/systemctl. See daemon.ts/daemonService.ts for the same
+ * pattern one layer down. */
+export async function ensureAgentConfigWithDaemon(projectId, root, ensureDaemonRunningFn = ensureDaemonRunning) {
+    const config = await ensureAgentConfig(projectId);
+    registerProject(projectId, root);
+    warnIfDaemonUnsupported(ensureDaemonRunningFn);
+    return config;
+}

package/dist/apiClient.js

@@ -0,0 +1,54 @@
+/**
+ * The single axios instance used for every call to the resumecontext cloud
+ * API (see httpCloudApi.ts) -- all 401 handling lives here, once, instead
+ * of in every command. A 401 always means the same thing (the token isn't
+ * good, whether because no session was ever established or because it
+ * expired) and always has the same fix (`resumecontext auth`), so this is
+ * the one place that clears local credentials and picks the right message
+ * for which of those two cases the user is actually in.
+ *
+ * Other error responses are propagated as a plain Error carrying whatever
+ * message the API sent -- no custom error class (see cloudApi.ts's module
+ * doc): the message text IS the UI. When an HTTP status is available it is
+ * also attached on the error object (see apiErrorStatus) so callers can
+ * distinguish failure kinds programmatically; display code still just uses
+ * the message.
+ */
+import axios from "axios";
+import { API_REQUEST_TIMEOUT_MS } from "./constants.js";
+import { readCredentials, clearCredentials } from "./session.js";
+export const apiClient = axios.create({
+    baseURL: process.env.RESUMECONTEXT_API_URL || "https://api.resumecontext.com",
+    timeout: API_REQUEST_TIMEOUT_MS,
+});
+function messageFromResponseBody(data, fallback) {
+    if (data && typeof data === "object" && "message" in data && typeof data.message === "string") {
+        return data.message;
+    }
+    return fallback;
+}
+function apiError(message, status) {
+    return Object.assign(new Error(message), { status });
+}
+export function apiErrorStatus(err) {
+    return err instanceof Error ? err.status : undefined;
+}
+apiClient.interceptors.response.use((response) => response, (error) => {
+    if (axios.isAxiosError(error)) {
+        if (error.response) {
+            const { status, data } = error.response;
+            if (status === 401) {
+                const hadCredentials = readCredentials() !== null;
+                clearCredentials();
+                throw apiError(hadCredentials
+                    ? "Your session has expired. Run `resumecontext auth` again."
+                    : "You're not logged in. Run `resumecontext auth` first.", 401);
+            }
+            throw apiError(messageFromResponseBody(data, error.message), status);
+        }
+        // Request was made but no response came back at all (offline, DNS
+        // failure, connection refused, timeout).
+        throw new Error("Couldn't reach resumecontext.com. Check your connection and try again.");
+    }
+    throw error;
+});

package/dist/browser.js

@@ -0,0 +1,20 @@
+import { spawn } from "node:child_process";
+/** Best-effort -- opens the user's default browser to `url`. Never throws:
+ * the CLI always prints the URL first, so a failure here just means the
+ * user opens it by hand instead of automatically. */
+export function openInBrowser(url) {
+    try {
+        if (process.platform === "darwin") {
+            spawn("open", [url], { stdio: "ignore", detached: true }).unref();
+        }
+        else if (process.platform === "win32") {
+            spawn("cmd", ["/c", "start", '""', url], { stdio: "ignore", detached: true, shell: true }).unref();
+        }
+        else {
+            spawn("xdg-open", [url], { stdio: "ignore", detached: true }).unref();
+        }
+    }
+    catch {
+        // fine -- URL was already printed
+    }
+}

package/dist/cloudApi.js

@@ -0,0 +1,15 @@
+/**
+ * The contract between this CLI and the resumecontext cloud service. Every
+ * command depends on this interface, never on a concrete implementation --
+ * that's what makes both real usage (HttpCloudApi, an axios-backed client
+ * in httpCloudApi.ts, pointed at the real backend/ over HTTP) and hermetic
+ * tests possible without the CLI code itself knowing which one it's talking
+ * to. Tests point that same HttpCloudApi at test/fakeBackendServer.ts's
+ * embedded HTTP server instead -- so it's real HTTP either way, including
+ * real status codes and a real 401 flow (see apiClient.ts).
+ *
+ * Failures are plain `Error`s with a user-facing message -- no custom error
+ * class. index.ts's top-level handler prints whatever message reaches it,
+ * so the message text IS the UI; write it accordingly at the throw site.
+ */
+export {};

package/dist/commands/accept.js

@@ -0,0 +1,20 @@
+/**
+ * `resumecontext accept` -- accepts the caller's own pending invite for the
+ * project marked in this directory. Requires `init` to have been run here
+ * first (init always writes the marker, even in the pending_invite case), so
+ * the explicit "no marker" failure this goal calls out by name is just
+ * requireProject()'s normal NO_PROJECT_HERE error.
+ */
+import { requireProject } from "../projectRoot.js";
+import { requireCredentials } from "../session.js";
+import * as ui from "../ui.js";
+export async function runAccept(deps) {
+    ui.intro("accept");
+    const { token } = requireCredentials();
+    const { root, projectId } = requireProject(deps.cwd);
+    await deps.ensureAgentConfig(projectId, root);
+    const { mcpUrl } = await ui.withSpinner("Accepting invite...", "Accepted.", () => deps.cloudApi.acceptInvite(token, projectId));
+    ui.log.info(`MCP URL: ${mcpUrl}`);
+    ui.outro("Run `resumecontext mcp` for the URL plus the token your agent needs, then `resumecontext sync` any time.");
+    return { mcpUrl };
+}

package/dist/commands/agents.js

@@ -0,0 +1,35 @@
+/**
+ * `resumecontext agents` -- reconfigure which coding agents this CLI scans
+ * for local history for THIS project, and where their data lives. The
+ * config is per-project (see agentConfig.ts), so like every other
+ * project-scoped command this needs `init` to have been run here first.
+ */
+import { requireProject } from "../projectRoot.js";
+import { requireCredentials } from "../session.js";
+import { promptForAgentConfig, readAgentConfig } from "../agentConfig.js";
+import { AGENT_ADAPTERS } from "../localHistory/registry.js";
+import * as ui from "../ui.js";
+export async function runAgents(deps) {
+    ui.intro("agents");
+    requireCredentials();
+    const { projectId } = requireProject(deps.cwd);
+    const existing = readAgentConfig(projectId);
+    if (existing && Object.keys(existing.agents).length > 0) {
+        ui.log.info("Currently syncing from:");
+        for (const [name, cfg] of Object.entries(existing.agents)) {
+            ui.log.info(`  ${AGENT_ADAPTERS[name].label}`);
+            for (const dir of cfg.dirs)
+                ui.log.info(`    ${dir}`);
+        }
+    }
+    // Deliberately does NOT register the project or ensure the daemon is
+    // running: `init` already registered it (this command requires a project,
+    // and init is the only way to get one), and the daemon re-reads each
+    // project's agent config at the top of every tick -- so a running daemon
+    // picks this up within seconds on its own. Ensuring the daemon here would
+    // also silently undo an explicit `daemon stop`, which should stay stopped
+    // until the user runs something that actually needs to sync.
+    const config = await promptForAgentConfig(projectId, existing);
+    ui.outro("Saved.");
+    return config;
+}

package/dist/commands/auth.js

@@ -0,0 +1,55 @@
+/**
+ * `resumecontext auth` -- browser-based login. The CLI mints a device code,
+ * shows/opens a link to resumecontext.com, and polls until the user has
+ * signed in (or signed up -- same page, same flow) over there. No password
+ * or email ever passes through the CLI itself.
+ */
+import { AUTH_POLL_INTERVAL_MS, DEVICE_CODE_TTL_MS } from "../constants.js";
+import { readCredentials, writeCredentials } from "../session.js";
+import { openInBrowser } from "../browser.js";
+import { sleep } from "../utils.js";
+import * as ui from "../ui.js";
+import { ensureDaemonRunning } from "../daemon.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.");
+    }
+}
+async function pollForLogin(deps, deviceCode, pollIntervalMs, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const result = await deps.cloudApi.pollDeviceLogin(deviceCode);
+        if (result.status === "complete")
+            return { token: result.token, email: result.email };
+        if (result.status === "expired")
+            throw new Error("Didn't finish signing in in the browser. Run `resumecontext auth` again.");
+        await sleep(pollIntervalMs);
+    }
+    throw new Error("Didn't finish signing in in the browser. Run `resumecontext auth` again.");
+}
+export async function runAuth(deps, opts = {}) {
+    ui.intro("auth");
+    // Logging in again while a session already exists would silently replace
+    // it -- surprising if the user just forgot they were logged in, and
+    // confusing if they meant to switch accounts (the old token stays valid
+    // server-side). Make them log out explicitly instead. Not an error: this
+    // is the "you're already all set" case, so exit 0.
+    const existing = readCredentials();
+    if (existing) {
+        startDaemonAfterAuth(opts.ensureDaemonRunning ?? ensureDaemonRunning);
+        ui.log.info(`You're already logged in as ${existing.email}.`);
+        ui.outro("Run `resumecontext logout` first if you want to switch accounts.");
+        return { email: existing.email };
+    }
+    const { verificationUrl, deviceCode } = await deps.cloudApi.startDeviceLogin();
+    opts.onVerificationUrl?.(verificationUrl);
+    ui.log.info("Opening your browser to sign in (or create an account) at resumecontext.com...");
+    ui.log.info(`If it doesn't open automatically, visit:\n  ${verificationUrl}`);
+    (opts.openBrowser ?? openInBrowser)(verificationUrl);
+    const { token, email } = await ui.withSpinner("Waiting for you to finish signing in in your browser...", "Signed in.", () => pollForLogin(deps, deviceCode, opts.pollIntervalMs ?? AUTH_POLL_INTERVAL_MS, opts.timeoutMs ?? DEVICE_CODE_TTL_MS));
+    writeCredentials({ token, email });
+    startDaemonAfterAuth(opts.ensureDaemonRunning ?? ensureDaemonRunning);
+    ui.outro(`Logged in as ${email}.`);
+    return { email };
+}

package/dist/commands/daemon.js

@@ -0,0 +1,99 @@
+/**
+ * `resumecontext daemon status` / `start` / `stop` -- inspect, (re)enable,
+ * or turn off the background auto-sync schedule. Separate from every other
+ * command: this doesn't operate on a specific project (once scheduled, it
+ * covers every configured project on this machine at once), so unlike
+ * project-scoped commands it needs no marker and no login.
+ *
+ * `stop` exists because installPersistentService (see daemonService.ts)
+ * registers a real OS-managed schedule (launchd StartInterval / a systemd
+ * timer) -- once that's in place, there needs to be an equally real way to
+ * turn it back off, not just killing whatever tick happens to be running
+ * (the OS would just fire the next one on schedule regardless).
+ *
+ * `start` exists for the reverse: every project-scoped command already
+ * calls ensureDaemonRunning() on its own (see agentConfigWithDaemon.ts), so
+ * 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 { findProjectRoot } from "../projectRoot.js";
+import * as ui from "../ui.js";
+/** Resolve each registry entry exactly as a daemon tick does, so status can
+ * show both what is registered and whether it is currently eligible to sync. */
+export function registeredProjectStatuses() {
+    return Object.entries(readRegistry().projects).map(([projectId, { root }]) => {
+        const resolved = findProjectRoot(root);
+        if (!resolved.projectId)
+            return { projectId, root, state: "missing_marker" };
+        if (resolved.projectId !== projectId) {
+            return {
+                projectId,
+                root,
+                state: "mismatched_marker",
+                markerRoot: resolved.root,
+                markerProjectId: resolved.projectId,
+            };
+        }
+        return { projectId, root, state: "ready", markerRoot: resolved.root };
+    });
+}
+export async function runDaemonStatus() {
+    ui.intro("daemon status");
+    const platform = detectPlatform();
+    const running = isServiceActive();
+    if (running) {
+        ui.log.success(`Auto-sync is running (registered with ${platform === "launchd" ? "launchd" : "systemd"} -- ` +
+            "survives crashes and reboots).");
+    }
+    else if (platform === "unsupported") {
+        ui.log.warn("Auto-sync isn't available on this OS (no launchd or systemd found) -- run `resumecontext sync` manually.");
+    }
+    else {
+        ui.log.info("Auto-sync is not running. It starts again after `resumecontext auth` or a project command like `sync`.");
+    }
+    const projects = registeredProjectStatuses();
+    if (projects.length === 0) {
+        ui.log.info("No projects are registered for background sync yet.");
+    }
+    else {
+        ui.log.info(`Background sync projects (${projects.length}):`);
+        for (const project of projects) {
+            if (project.state === "ready") {
+                const moved = project.markerRoot !== project.root ? ` (marker at ${project.markerRoot})` : "";
+                ui.log.info(`  ${project.projectId}\n    ${project.root}${moved}`);
+            }
+            else if (project.state === "missing_marker") {
+                ui.log.warn(`  ${project.projectId} — skipped: no .resumecontext.json at ${project.root} or its parents`);
+            }
+            else {
+                ui.log.warn(`  ${project.projectId} — skipped: marker at ${project.markerRoot} belongs to ${project.markerProjectId}`);
+            }
+        }
+    }
+    ui.outro(running ? "Running." : "Not running.");
+    return { running, projects };
+}
+export async function runDaemonStart() {
+    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.");
+        return { started: false };
+    }
+    const { installed } = installPersistentService();
+    ui.outro(installed
+        ? `Auto-sync started (registered with ${platform === "launchd" ? "launchd" : "systemd"} -- survives crashes and reboots).`
+        : "Auto-sync was already running.");
+    return { started: installed };
+}
+export async function runDaemonStop() {
+    ui.intro("daemon stop");
+    const { uninstalled } = uninstallPersistentService();
+    ui.outro(uninstalled
+        ? "Auto-sync stopped. It starts again after `resumecontext auth` or a project command like `sync`."
+        : "Auto-sync wasn't running.");
+    return { stopped: uninstalled };
+}

package/dist/commands/init.js

@@ -0,0 +1,59 @@
+/**
+ * `resumecontext init` -- the flagship command, and the only one that prints
+ * the big ASCII banner (per the goal: "When init is run, it should print out
+ * the name of the app... in big and nice ascii art").
+ *
+ * Marks the EXACT directory init is run in (never auto-redirects to an
+ * enclosing git root) -- see projectRoot.ts's module doc for why: it's what
+ * lets a monorepo subfolder become its own project. Re-running init in a
+ * directory that already has its own marker is a no-op-ish "already set up"
+ * confirmation, not an error.
+ *
+ * Project identity is ONLY ever the local marker's projectId -- nothing is
+ * derived from git remotes or file paths. So: no marker in this exact
+ * directory means create a new project; a marker here (written by a prior
+ * `init`, or because the marker file was committed to git and this is a
+ * fresh clone of a project someone else already registered) means look that
+ * project up and report this caller's relationship to it.
+ */
+import path from "node:path";
+import { findProjectRoot, writeMarker } from "../projectRoot.js";
+import { requireCredentials } from "../session.js";
+import * as ui from "../ui.js";
+export async function runInit(deps) {
+    ui.printBanner();
+    ui.intro("init");
+    const { token } = requireCredentials();
+    const cwd = path.resolve(deps.cwd);
+    const existing = findProjectRoot(cwd);
+    const existingProjectId = existing.projectId && existing.root === cwd ? existing.projectId : null;
+    const outcome = await ui.withSpinner("Talking to resumecontext.com...", "Done.", async () => {
+        if (existingProjectId)
+            return deps.cloudApi.findProject(token, existingProjectId);
+        const created = await deps.cloudApi.createProject(token, path.basename(cwd));
+        return { status: "created", ...created };
+    });
+    // Every outcome gets a local marker -- accept (and any other project-scoped
+    // command) requires one to exist, even before a pending invite is accepted.
+    writeMarker(cwd, outcome.projectId);
+    // Only now, once the project has an id, can its agent config be looked up
+    // or prompted for -- the config is keyed by that id (see agentConfig.ts).
+    await deps.ensureAgentConfig(outcome.projectId, cwd);
+    switch (outcome.status) {
+        case "created":
+            ui.log.success(`New project created for ${cwd}`);
+            ui.log.info(`MCP URL: ${outcome.mcpUrl}`);
+            ui.outro("Run `resumecontext mcp` for the URL plus the token your agent needs, then `resumecontext sync` any time.");
+            break;
+        case "already_has_access":
+            ui.log.info("This project is already set up.");
+            ui.log.info(`MCP URL: ${outcome.mcpUrl}`);
+            ui.outro("Run `resumecontext mcp` to configure your agent, or `resumecontext sync` to push the latest local context.");
+            break;
+        case "pending_invite":
+            ui.log.warn(`You have a pending invite for this project as ${outcome.invitedEmail}.`);
+            ui.outro("Run `resumecontext accept` to accept it.");
+            break;
+    }
+    return outcome;
+}

package/dist/commands/logout.js

@@ -0,0 +1,20 @@
+/**
+ * `resumecontext logout` -- clears this machine's stored session so a
+ * different account can log in. Local only: it does not revoke the token
+ * server-side, and it deliberately leaves agent config and per-project sync
+ * state alone, since those aren't account-specific and re-collecting them
+ * after every account switch would be pointless busywork.
+ */
+import { readCredentials, clearCredentials } from "../session.js";
+import * as ui from "../ui.js";
+export async function runLogout() {
+    ui.intro("logout");
+    const existing = readCredentials();
+    if (!existing) {
+        ui.outro("You're not logged in.");
+        return { loggedOut: false };
+    }
+    clearCredentials();
+    ui.outro(`Logged out ${existing.email}.`);
+    return { loggedOut: true };
+}