@telepath-computer/stash 0.2.4 → 0.3.1

package/dist/cli-main.js

@@ -1,11 +1,13 @@
 import { existsSync } from "node:fs";
-import { access, constants, readFile } from "node:fs/promises";
+import { access, constants, readFile, rm } from "node:fs/promises";
 import { basename, delimiter, join, resolve } from "node:path";
 import { Daemon, UnsupportedPlatformError } from "@rupertsworld/daemon";
 import { Command, Option } from "commander";
 import { input, password } from "@inquirer/prompts";
 import { addBackgroundStash, getBackgroundStashes, getProviderConfig, readGlobalConfig, removeBackgroundStash, setProviderConfig, writeGlobalConfig, } from "./global-config.js";
+import { readLocalConfig, writeLocalConfig } from "./local-config.js";
 import { runDaemon } from "./daemon.js";
+import { needsMigration } from "./migrations.js";
 import { providers } from "./providers/index.js";
 import { Stash } from "./stash.js";
 import { createColors } from "./ui/color.js";
@@ -15,6 +17,13 @@ import { SyncRenderer } from "./ui/sync-renderer.js";
 import { watch as watchStash } from "./watch.js";
 const SERVICE_NAME = "stash-background";
 const SERVICE_DESCRIPTION = "Stash background sync";
+const STASH_CONFIG_KEYS = new Set(["allow-git"]);
+function isStashConfigKey(key) {
+    return STASH_CONFIG_KEYS.has(key);
+}
+function isStashDirectory(dir) {
+    return existsSync(join(dir, ".stash"));
+}
 function getProvider(name) {
     const provider = providers[name];
     if (!provider) {
@@ -37,12 +46,32 @@ function writeLine(stream, text) {
 function isUnsupportedPlatformError(error) {
     return error instanceof UnsupportedPlatformError;
 }
-export async function resolveStashCommand() {
-    const argvPath = process.argv[1];
-    if (argvPath && basename(argvPath) === "stash") {
-        const candidate = resolve(argvPath);
+async function bounceDaemonIfMigrationNeeded(dir, getService) {
+    if (!isStashDirectory(dir) || !needsMigration(dir)) {
+        return false;
+    }
+    try {
+        const service = await getService();
+        const status = await service.status();
+        if (!status.running) {
+            return false;
+        }
+        await service.uninstall();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function resolveServiceLaunch(argv = process.argv) {
+    const invokedPath = argv[1];
+    if (invokedPath) {
+        const candidate = resolve(invokedPath);
         if (await isExecutable(candidate)) {
-            return candidate;
+            return { command: candidate, args: ["daemon"] };
+        }
+        if (existsSync(candidate)) {
+            return { command: process.execPath, args: [candidate, "daemon"] };
         }
     }
     for (const pathEntry of (process.env.PATH ?? "").split(delimiter)) {
@@ -51,10 +80,10 @@ export async function resolveStashCommand() {
         }
         const candidate = join(pathEntry, "stash");
         if (await isExecutable(candidate)) {
-            return candidate;
+            return { command: candidate, args: ["daemon"] };
         }
     }
-    throw new Error("Could not find the `stash` binary on PATH");
+    throw new Error("Could not resolve a command to run `stash daemon`");
 }
 async function promptField(field) {
     if (field.secret) {
@@ -84,23 +113,30 @@ async function readBackgroundStatus(dir) {
     }
     return JSON.parse(await readFile(statusPath, "utf8"));
 }
-async function warnIfServiceUnavailable(serviceHandle, stderr) {
-    if (!serviceHandle) {
+function renderGitWarning(stdout) {
+    const { dim, yellow } = createColors(stdout);
+    writeLine(stdout, `${yellow("Warning:")} ${dim("This directory contains .git. Stash will not sync until you either:")}`);
+    writeLine(stdout, dim("  - remove .git, or"));
+    writeLine(stdout, dim('  - run `stash config set allow-git true` (see "Using stash with git" in the README)'));
+}
+async function warnIfGitSyncBlocked(dir, stdout) {
+    if (!existsSync(join(dir, ".git"))) {
         return;
     }
-    try {
-        const status = await serviceHandle.status();
-        if (!status.installed) {
-            writeLine(stderr, "warning: background service is not installed");
-        }
+    const localConfig = await readLocalConfig(dir);
+    if (localConfig["allow-git"] === true) {
+        return;
     }
-    catch (error) {
-        if (isUnsupportedPlatformError(error)) {
-            writeLine(stderr, "warning: service install is not supported on this platform yet; run `stash background watch` manually");
-            return;
-        }
-        throw error;
+    renderGitWarning(stdout);
+}
+function parseConfigValue(key, value) {
+    if (value === "true") {
+        return true;
+    }
+    if (value === "false") {
+        return false;
     }
+    throw new Error(`Invalid value for ${key}: expected true or false`);
 }
 async function runSetup(providerName, valuesFromCli, deps, stdout) {
     const provider = getProvider(providerName);
@@ -110,22 +146,8 @@ async function runSetup(providerName, valuesFromCli, deps, stdout) {
     await deps.writeGlobalConfig(globalConfig);
     writeLine(stdout, `Configured ${providerName}.`);
 }
-async function runInit(cwd, readConfig, stdout) {
-    const dir = cwd();
-    const alreadyInitialized = existsSync(join(dir, ".stash"));
-    await Stash.init(dir, await readConfig());
-    writeLine(stdout, alreadyInitialized ? "Already initialized." : "Initialized stash.");
-}
-async function registerBackgroundStash(dir, readConfig, writeConfig, serviceHandle, stderr) {
-    const globalConfig = await readConfig();
-    const stash = await Stash.load(dir, globalConfig);
-    if (Object.keys(stash.connections).length === 0) {
-        writeLine(stderr, "warning: this stash won't sync until a provider is connected");
-    }
-    await writeConfig(addBackgroundStash(globalConfig, dir));
-    await warnIfServiceUnavailable(serviceHandle, stderr);
-}
-async function runConnect(providerName, valuesFromCli, deps, stdout, stderr) {
+async function runConnect(providerName, valuesFromCli, deps, stdout) {
+    const { dim, green } = createColors(stdout);
     const provider = getProvider(providerName);
     let globalConfig = await deps.readGlobalConfig();
     const setupValues = await collectFields(provider.spec.setup, valuesFromCli, getProviderConfig(globalConfig, providerName));
@@ -135,14 +157,47 @@ async function runConnect(providerName, valuesFromCli, deps, stdout, stderr) {
     const stash = await Stash.init(dir, globalConfig);
     const connectValues = await collectFields(provider.spec.connect, valuesFromCli);
     await stash.connect(providerName, connectValues);
-    if (valuesFromCli.background === true) {
-        await registerBackgroundStash(dir, deps.readGlobalConfig, deps.writeGlobalConfig, deps.service, stderr);
-    }
+    globalConfig = await deps.readGlobalConfig();
+    await deps.writeGlobalConfig(addBackgroundStash(globalConfig, resolve(dir)));
     writeLine(stdout, `Connected ${providerName}.`);
+    await warnIfGitSyncBlocked(dir, stdout);
+    if (!deps.getService) {
+        return;
+    }
+    try {
+        const status = await (await deps.getService()).status();
+        if (status.running) {
+            writeLine(stdout, `${green("Background sync is on")} ${dim("·")} ${dim("This stash is now syncing automatically")}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            error.message === "Could not resolve a command to run `stash daemon`") {
+            return;
+        }
+        if (!isUnsupportedPlatformError(error)) {
+            throw error;
+        }
+    }
 }
-async function runDisconnect(providerName, cwd, readConfig, stdout) {
-    const stash = await Stash.load(cwd(), await readConfig());
+async function runDisconnect(providerName, cwd, readConfig, writeConfig, stdout) {
+    const dir = cwd();
+    const globalConfig = await readConfig();
+    const stash = await Stash.load(dir, globalConfig);
+    if (!providerName) {
+        for (const name of Object.keys(stash.connections)) {
+            await stash.disconnect(name);
+        }
+        await writeConfig(removeBackgroundStash(globalConfig, resolve(dir)));
+        await rm(join(dir, ".stash"), { recursive: true, force: true });
+        writeLine(stdout, "Disconnected stash.");
+        return;
+    }
     await stash.disconnect(providerName);
+    if (Object.keys(stash.connections).length === 0) {
+        await writeConfig(removeBackgroundStash(globalConfig, resolve(dir)));
+        await rm(join(dir, ".stash"), { recursive: true, force: true });
+    }
     writeLine(stdout, `Disconnected ${providerName}.`);
 }
 async function runSync(cwd, readConfig) {
@@ -188,14 +243,116 @@ function formatChangeParts(status) {
         parts.push(`${status.deleted.length} deleted`);
     return parts;
 }
-async function runStatus(cwd, readConfig, stdout) {
-    const { dim, green, yellow } = createColors(stdout);
-    const stash = await Stash.load(cwd(), await readConfig());
+function formatStashCount(count) {
+    return `${count} ${count === 1 ? "stash" : "stashes"}`;
+}
+async function runStatusAll(readConfig, serviceHandle, stdout) {
+    const { dim, green, red } = createColors(stdout);
+    const globalConfig = await readConfig();
+    const stashes = getBackgroundStashes(globalConfig);
+    if (stashes.length === 0) {
+        writeLine(stdout, "No stashes connected yet — run `stash connect <provider>` in a directory to add one");
+        return;
+    }
+    try {
+        const current = await serviceHandle.status();
+        if (current.running) {
+            writeLine(stdout, `${green("Background sync is on")} ${dim("·")} ${dim(`watching ${formatStashCount(stashes.length)}`)}`);
+        }
+        else {
+            writeLine(stdout, red("Background sync is off"));
+            writeLine(stdout, dim(`Run \`stash start\` to resume syncing ${formatStashCount(stashes.length)}`));
+        }
+    }
+    catch (error) {
+        if (isUnsupportedPlatformError(error)) {
+            writeLine(stdout, red("Background sync is not supported on this platform"));
+        }
+        else {
+            throw error;
+        }
+    }
+    writeLine(stdout, "");
+    for (const dir of stashes) {
+        const title = basename(dir);
+        if (!existsSync(dir)) {
+            writeLine(stdout, `${red("✗")} ${title}`);
+            writeLine(stdout, dim(`  ${dir}`));
+            writeLine(stdout, dim("  Directory not found"));
+            continue;
+        }
+        if (!isStashDirectory(dir)) {
+            writeLine(stdout, `${red("✗")} ${title}`);
+            writeLine(stdout, dim(`  ${dir}`));
+            writeLine(stdout, dim("  Not a stash"));
+            continue;
+        }
+        const stash = await Stash.load(dir, globalConfig);
+        const persistedStatus = await readBackgroundStatus(dir);
+        const localStatus = stash.status();
+        const connectionNames = Object.keys(stash.connections);
+        if (persistedStatus?.kind === "error") {
+            writeLine(stdout, `${red("✗")} ${title}`);
+            writeLine(stdout, dim(`  ${dir}`));
+            for (const providerName of connectionNames) {
+                const conn = stash.connections[providerName];
+                const label = conn.repo ?? Object.values(conn).join(", ");
+                writeLine(stdout, `  ${providerName}  ${label} ${dim("·")} ${red(persistedStatus.error ?? "unknown error")}`);
+            }
+            continue;
+        }
+        writeLine(stdout, `${green("●")} ${title}`);
+        writeLine(stdout, dim(`  ${dir}`));
+        for (const providerName of connectionNames) {
+            const conn = stash.connections[providerName];
+            const label = conn.repo ?? Object.values(conn).join(", ");
+            if (persistedStatus === null || localStatus.lastSync === null) {
+                writeLine(stdout, `  ${providerName}  ${label} ${dim("·")} ${dim("Waiting for first sync")}`);
+                continue;
+            }
+            const parts = formatChangeParts(localStatus);
+            if (parts.length > 0) {
+                writeLine(stdout, `  ${providerName}  ${label} ${dim("·")} Local changes: ${parts.join(", ")} ${dim("·")} ${dim(`synced ${formatTimeAgo(localStatus.lastSync)}`)}`);
+            }
+            else {
+                writeLine(stdout, `  ${providerName}  ${label} ${dim("·")} ${dim(`Up to date · synced ${formatTimeAgo(localStatus.lastSync)}`)}`);
+            }
+        }
+    }
+}
+async function runStatus(cwd, readConfig, serviceHandle, stdout) {
+    const { dim, green, yellow, red } = createColors(stdout);
+    const dir = cwd();
+    if (!isStashDirectory(dir)) {
+        throw new Error("Not in a stash directory — run `stash status --all` to view all stashes");
+    }
+    const globalConfig = await readConfig();
+    const stash = await Stash.load(dir, globalConfig);
     const connectionNames = Object.keys(stash.connections);
     if (connectionNames.length === 0) {
-        writeLine(stdout, dim("no connections — run `stash connect <provider>` to get started"));
+        writeLine(stdout, dim("No connections — run `stash connect <provider>` to get started"));
         return;
     }
+    if (getBackgroundStashes(globalConfig).includes(resolve(dir))) {
+        try {
+            const current = await serviceHandle.status();
+            if (current.running) {
+                writeLine(stdout, `${green("Background sync is on")} ${dim("·")} ${dim("Use `stash status --all` to view all stashes")}`);
+            }
+            else {
+                writeLine(stdout, `${red("Background sync is off")} ${dim("·")} ${dim("Run `stash start` to keep connected stashes in sync")}`);
+            }
+        }
+        catch (error) {
+            if (isUnsupportedPlatformError(error)) {
+                writeLine(stdout, `${red("Background sync is not supported on this platform")}`);
+            }
+            else {
+                throw error;
+            }
+        }
+        writeLine(stdout, "");
+    }
     const status = stash.status();
     const parts = formatChangeParts(status);
     for (const name of connectionNames) {
@@ -206,118 +363,102 @@ async function runStatus(cwd, readConfig, stdout) {
         if (status.lastSync) {
             const ago = formatTimeAgo(status.lastSync);
             if (parts.length > 0) {
-                writeLine(stdout, `  ${parts.join(", ")} ${dim("·")} ${dim(`synced ${ago}`)}`);
+                writeLine(stdout, `  Local changes: ${parts.join(", ")} ${dim("·")} ${dim(`synced ${ago}`)}`);
             }
             else {
-                writeLine(stdout, dim(`  up to date · synced ${ago}`));
+                writeLine(stdout, dim(`  Up to date · synced ${ago}`));
             }
         }
         else if (parts.length > 0) {
-            writeLine(stdout, `  ${parts.join(", ")} ${dim("·")} ${dim("never synced")}`);
+            writeLine(stdout, `  Local changes: ${parts.join(", ")} ${dim("·")} ${dim("Never synced")}`);
         }
         else {
-            writeLine(stdout, dim("  never synced"));
+            writeLine(stdout, dim("  Never synced"));
         }
     }
 }
-async function runBackgroundInstall(serviceHandle, stdout) {
-    await serviceHandle.install();
-    writeLine(stdout, "Installed background service.");
-}
-async function runBackgroundUninstall(serviceHandle, stdout) {
-    await serviceHandle.uninstall();
-    writeLine(stdout, "Uninstalled background service.");
-}
-async function runBackgroundAdd(dirArg, cwd, readConfig, writeConfig, serviceHandle, stdout, stderr) {
-    const dir = resolve(dirArg ?? cwd());
-    await registerBackgroundStash(dir, readConfig, writeConfig, serviceHandle, stderr);
-    writeLine(stdout, `Registered ${dir} for background sync.`);
-}
-async function runBackgroundRemove(dirArg, cwd, readConfig, writeConfig, stdout) {
-    const dir = resolve(dirArg ?? cwd());
-    const globalConfig = await readConfig();
-    await writeConfig(removeBackgroundStash(globalConfig, dir));
-    writeLine(stdout, `Removed ${dir} from background sync.`);
-}
-async function runBackgroundStatus(readConfig, serviceHandle, stdout) {
+async function runStart(serviceHandle, readConfig, stdout) {
     const { dim, green, red } = createColors(stdout);
-    let serviceRunning = false;
-    let serviceMessage = null;
     try {
         const current = await serviceHandle.status();
-        if (!current.installed) {
-            serviceMessage = dim("service not installed — run `stash background install`");
-        }
-        else if (current.running) {
-            serviceRunning = true;
-        }
-        else {
-            serviceMessage = red("background service is stopped — run `stash background install` to restart");
+        if (current.installed && current.running) {
+            writeLine(stdout, green("Background sync is already running"));
+            return;
         }
     }
     catch (error) {
         if (isUnsupportedPlatformError(error)) {
-            serviceMessage = dim("service install not supported on this platform — run `stash background watch` manually");
-        }
-        else {
-            throw error;
+            writeLine(stdout, red("Background sync is not supported on this platform"));
+            process.exitCode = 1;
+            return;
         }
+        throw error;
     }
-    const globalConfig = await readConfig();
-    const stashes = getBackgroundStashes(globalConfig);
-    if (serviceRunning) {
-        writeLine(stdout, dim("stash is syncing in the background"));
+    await serviceHandle.install();
+    const count = getBackgroundStashes(await readConfig()).length;
+    writeLine(stdout, green("Background sync is on"));
+    writeLine(stdout, dim(`Watching ${formatStashCount(count)} · starts on startup`));
+}
+async function runStop(serviceHandle, readConfig, stdout) {
+    const { dim, red } = createColors(stdout);
+    try {
+        const current = await serviceHandle.status();
+        if (!current.installed && !current.running) {
+            writeLine(stdout, red("Background sync is not running"));
+            return;
+        }
     }
-    else if (serviceMessage) {
-        writeLine(stdout, serviceMessage);
+    catch (error) {
+        if (isUnsupportedPlatformError(error)) {
+            writeLine(stdout, red("Background sync is not running"));
+            return;
+        }
+        throw error;
     }
-    if (stashes.length === 0) {
-        writeLine(stdout, dim("\nno stashes registered — run `stash background add` to add one"));
-        return;
+    await serviceHandle.uninstall();
+    const count = getBackgroundStashes(await readConfig()).length;
+    writeLine(stdout, red("Background sync is off"));
+    writeLine(stdout, dim(`Run \`stash start\` to resume syncing ${formatStashCount(count)}`));
+}
+async function ensureInitializedStash(cwd, readConfig) {
+    const dir = cwd();
+    await Stash.load(dir, await readConfig());
+    return dir;
+}
+async function runConfigSet(key, value, cwd, readConfig, stdout) {
+    if (!isStashConfigKey(key)) {
+        throw new Error(`Unknown config key: ${key}`);
     }
-    writeLine(stdout, "");
-    for (const dir of stashes) {
-        if (!existsSync(dir)) {
-            writeLine(stdout, `${red("✗")} ${dir}`);
-            writeLine(stdout, dim("  directory not found"));
-            continue;
-        }
-        const status = await readBackgroundStatus(dir);
-        if (!status) {
-            writeLine(stdout, `${dim("○")} ${dir}`);
-            writeLine(stdout, dim("  waiting for first sync"));
-            continue;
-        }
-        if (status.kind === "error") {
-            writeLine(stdout, `${red("✗")} ${dir}`);
-            const ago = status.lastSync ? formatTimeAgo(new Date(status.lastSync)) : null;
-            const errorMsg = status.error ?? "unknown error";
-            writeLine(stdout, ago ? `  ${red(errorMsg)} ${dim("·")} ${dim(`synced ${ago}`)}` : `  ${red(errorMsg)}`);
-            continue;
-        }
-        const ago = status.lastSync ? formatTimeAgo(new Date(status.lastSync)) : null;
-        if (status.summary) {
-            writeLine(stdout, `${green("●")} ${dir}`);
-            writeLine(stdout, `  ${status.summary} ${dim("·")} ${dim(`synced ${ago ?? "unknown"}`)}`);
-        }
-        else {
-            writeLine(stdout, `${green("●")} ${dir}`);
-            writeLine(stdout, dim(`  up to date · synced ${ago ?? "unknown"}`));
-        }
+    const dir = await ensureInitializedStash(cwd, readConfig);
+    const currentConfig = await readLocalConfig(dir);
+    const nextConfig = {
+        ...currentConfig,
+        [key]: parseConfigValue(key, value),
+    };
+    await writeLocalConfig(dir, nextConfig);
+    writeLine(stdout, `${key}=${String(nextConfig[key])}`);
+}
+async function runConfigGet(key, cwd, readConfig, stdout) {
+    if (!isStashConfigKey(key)) {
+        throw new Error(`Unknown config key: ${key}`);
     }
+    const dir = await ensureInitializedStash(cwd, readConfig);
+    const localConfig = await readLocalConfig(dir);
+    const value = localConfig[key];
+    writeLine(stdout, value === undefined ? "" : String(value));
 }
 function addFieldOptions(command, fields) {
     for (const field of fields) {
         command.addOption(new Option(`--${field.name} <value>`, field.label));
     }
 }
-async function createDefaultService() {
-    const command = await resolveStashCommand();
+async function createDefaultService(argv = process.argv) {
+    const launch = await resolveServiceLaunch(argv);
     return new Daemon({
         name: SERVICE_NAME,
         description: SERVICE_DESCRIPTION,
-        command,
-        args: ["background", "watch"],
+        command: launch.command,
+        args: launch.args,
         env: process.env.PATH ? { PATH: process.env.PATH } : undefined,
     });
 }
@@ -326,10 +467,25 @@ export async function main(argv = process.argv, deps = {}) {
     const readConfig = deps.readGlobalConfig ?? readGlobalConfig;
     const writeConfig = deps.writeGlobalConfig ?? writeGlobalConfig;
     const serviceHandle = deps.service;
-    const getService = async () => serviceHandle ?? (await createDefaultService());
+    const getService = async () => serviceHandle ?? (await createDefaultService(argv));
     const runDaemonCommand = deps.runDaemon ?? runDaemon;
     const stdout = deps.stdout ?? process.stdout;
     const stderr = deps.stderr ?? process.stderr;
+    const dirsToCheck = [cwd()];
+    try {
+        const config = await readConfig();
+        dirsToCheck.push(...getBackgroundStashes(config));
+    }
+    catch {
+        // Global config unreadable — skip migration check.
+    }
+    let daemonBounced = false;
+    for (const dir of dirsToCheck) {
+        if (await bounceDaemonIfMigrationNeeded(dir, getService)) {
+            daemonBounced = true;
+            break;
+        }
+    }
     const program = new Command()
         .name("stash")
         .description("Conflict-free synced folders")
@@ -354,30 +510,22 @@ export async function main(argv = process.argv, deps = {}) {
         .command("connect")
         .description("Connect this stash to a provider")
         .argument("<provider>", "Provider name")
-        .option("--background", "Register this stash for background syncing")
         .allowUnknownOption(true)
         .action(async (providerName, _opts, command) => {
         const opts = command.opts();
-        const svc = opts.background === true ? await getService() : undefined;
         await runConnect(providerName, opts, {
             cwd,
             readGlobalConfig: readConfig,
             writeGlobalConfig: writeConfig,
-            service: svc,
-        }, stdout, stderr);
+            getService,
+        }, stdout);
     });
     program
         .command("disconnect")
         .description("Disconnect provider from this stash")
-        .argument("<provider>", "Provider name")
+        .argument("[provider]", "Provider name")
         .action(async (providerName) => {
-        await runDisconnect(providerName, cwd, readConfig, stdout);
-    });
-    program
-        .command("init")
-        .description("Initialize the current directory as a stash")
-        .action(() => {
-        return runInit(cwd, readConfig, stdout);
+        await runDisconnect(providerName, cwd, readConfig, writeConfig, stdout);
     });
     program
         .command("sync")
@@ -390,35 +538,37 @@ export async function main(argv = process.argv, deps = {}) {
     program
         .command("status")
         .description("Show local stash status")
-        .action(() => runStatus(cwd, readConfig, stdout));
-    const backgroundCommand = program.command("background").description("Manage background syncing");
-    backgroundCommand
-        .command("install")
-        .description("Install the background service")
-        .action(async () => runBackgroundInstall(await getService(), stdout));
-    backgroundCommand
-        .command("uninstall")
-        .description("Remove the background service")
-        .action(async () => runBackgroundUninstall(await getService(), stdout));
-    backgroundCommand
-        .command("add")
-        .description("Register a stash for background syncing")
-        .argument("[dir]", "Stash directory")
-        .action(async (dirArg) => {
-        const svc = await getService().catch(() => undefined);
-        await runBackgroundAdd(dirArg, cwd, readConfig, writeConfig, svc, stdout, stderr);
+        .option("--all", "Show all connected stashes")
+        .action(async (_opts, command) => {
+        const opts = command.opts();
+        if (opts.all) {
+            await runStatusAll(readConfig, await getService(), stdout);
+            return;
+        }
+        await runStatus(cwd, readConfig, await getService(), stdout);
     });
-    backgroundCommand
-        .command("remove")
-        .description("Unregister a stash from background syncing")
-        .argument("[dir]", "Stash directory")
-        .action((dirArg) => runBackgroundRemove(dirArg, cwd, readConfig, writeConfig, stdout));
-    backgroundCommand
-        .command("status")
-        .description("Show background service and stash status")
-        .action(async () => runBackgroundStatus(readConfig, await getService(), stdout));
-    backgroundCommand
-        .command("watch", { hidden: true })
+    const configCommand = program.command("config").description("Manage stash config");
+    configCommand
+        .command("set")
+        .description("Set a stash config value")
+        .argument("<key>", "Config key")
+        .argument("<value>", "Config value")
+        .action((key, value) => runConfigSet(key, value, cwd, readConfig, stdout));
+    configCommand
+        .command("get")
+        .description("Get a stash config value")
+        .argument("<key>", "Config key")
+        .action((key) => runConfigGet(key, cwd, readConfig, stdout));
+    program
+        .command("start")
+        .description("Start background sync")
+        .action(async () => runStart(await getService(), readConfig, stdout));
+    program
+        .command("stop")
+        .description("Stop background sync")
+        .action(async () => runStop(await getService(), readConfig, stdout));
+    program
+        .command("daemon", { hidden: true })
         .description("Run the background daemon")
         .action(() => runDaemonCommand());
     const commandName = argv[2];
@@ -439,5 +589,14 @@ export async function main(argv = process.argv, deps = {}) {
         return;
     }
     await program.parseAsync(argv);
+    const skipRestart = commandName === "stop" || commandName === "daemon";
+    if (daemonBounced && !skipRestart) {
+        try {
+            await (await getService()).install();
+        }
+        catch {
+            // Best-effort restart — service may be unsupported or unavailable.
+        }
+    }
 }
 //# sourceMappingURL=cli-main.js.map