@nessielabs/daemon 0.4.0 → 0.5.26

package/README.md

@@ -1,15 +1,15 @@
 # Nessie Daemon
 
-Headless Linux ingestion daemon for Nessie agent traces.
+Headless Nessie command line interface.
 
 ## Install
 
 ```bash
 npm install -g @nessielabs/daemon
-nessie-daemon setup
+nessie-daemon login
 ```
 
-`setup` authenticates the device, detects local Codex and Claude Code history directories, lets you choose which sources to ingest, and can install the user `systemd` service.
+`login` starts Nessie, signs in through the browser, detects local agent history directories, lets you configure data integrations, and starts ingestion plus cloud sync.
 
 For non-interactive headless setup, pass a Nessie API key:
 
@@ -21,6 +21,7 @@ nessie-daemon start
 ## Commands
 
 ```bash
+nessie-daemon login
 nessie-daemon setup
 nessie-daemon run --once
 nessie-daemon start
@@ -28,22 +29,12 @@ nessie-daemon stop
 nessie-daemon status
 ```
 
-The daemon registers selected local resources through sync preflight, pulls this device's cloud sync state, and pushes local agent traces.
-
-Config is stored at `~/.config/nessie-daemon/config.json`; the local sync graph is stored at `~/.local/state/nessie-daemon/nessie.sqlite`.
+The package installs only the `nessie-daemon` binary to avoid colliding with the Nessie Mac CLI.
 
-Re-running `setup` rewrites the source selection. The daemon reparses selected local history, reconciles it into SQLite, and only pushes rows whose local graph state has not been acknowledged by the cloud.
+The npm daemon package embeds the Nessie runtime for the current platform. Node is a one-shot CLI wrapper: commands start or configure Nessie and then exit, while the background service remains running.
 
 ## systemd
 
-`setup` can install a user service at:
-
-```bash
-~/.config/systemd/user/nessie-daemon.service
-```
-
-On long-running headless VMs, enable user services to survive logout:
+`nessie-daemon start` starts Nessie, enables ingestion and cloud sync timers, and exits. `nessie-daemon run` does the same for backwards compatibility. Logs are written under the user-local daemon state directory.
 
-```bash
-sudo loginctl enable-linger "$USER"
-```
+Existing user systemd units that invoke `nessie-daemon run` will only start or probe Nessie and then exit. They are no longer required and should be disabled or removed. This package no longer writes new systemd unit files itself.

package/dist/cli.js

@@ -1,40 +1,61 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
 import { Command } from "commander";
-import { runDaemon } from "./commands/run.js";
-import { runServiceCommand } from "./commands/service.js";
-import { runSetup } from "./commands/setup.js";
-// Read the version from package.json so the reported version can never drift
-// from the published one. ../package.json resolves from both dist/cli.js
-// (installed) and src/cli.ts (tsx dev path), since both sit one level under
-// the package root, and npm always includes package.json in the tarball.
+import { registerAuthCommands } from "./commands/auth.js";
+import { registerIntegrationCommands } from "./commands/integrations.js";
+import { login } from "./commands/login.js";
+import { run } from "./commands/run.js";
+import { service } from "./commands/service.js";
+import { registerSharingCommands } from "./commands/sharing.js";
+import { status } from "./commands/status.js";
+import { registerTeamCommands } from "./commands/teams.js";
 const require = createRequire(import.meta.url);
 const { version } = require("../package.json");
 const program = new Command();
 program
     .name("nessie-daemon")
-    .description("Headless Nessie ingestion daemon for Linux agent machines.")
+    .description("Nessie command line interface.")
     .version(version);
 program
-    .command("setup")
-    .description("Authenticate, select local sources, and optionally install the user systemd service.")
+    .command("login")
+    .alias("setup")
+    .description("Sign in, configure data integrations, and start Nessie.")
     .option("--api-key <key>", "Use a Nessie API key for non-interactive headless setup.")
-    .action(runSetup);
+    .option("--no-open", "Print the browser sign-in URL instead of opening it.")
+    .option("--no-background", "Do not start the background service after setup.")
+    .action(login);
 program
     .command("run")
-    .description("Run the daemon sync loop.")
-    .option("--once", "Run one sync pass and exit.")
-    .option("--interval-seconds <seconds>", "Seconds between sync passes.", "60")
-    .action(runDaemon);
+    .description("Start Nessie and enable background processing.")
+    .option("--once", "Trigger one ingestion and cloud-sync cycle, then exit.")
+    .option("--interval-seconds <seconds>", "Ignored compatibility option from the old daemon.")
+    .action(run);
+registerAuthCommands(program);
+registerIntegrationCommands(program);
+registerSharingCommands(program);
+registerTeamCommands(program);
 program
     .command("start")
-    .description("Start the daemon.")
-    .option("--background", "Start as a detached background process without systemd.")
-    .action((options) => runServiceCommand("start", options));
+    .description("Start Nessie in the background.")
+    .option("--background", "Compatibility flag; background mode is the default.")
+    .action(async () => printIfPresent(await service("start")));
 for (const commandName of ["stop", "status"]) {
     program
         .command(commandName)
-        .description(`${commandName[0]?.toUpperCase()}${commandName.slice(1)} the daemon.`)
-        .action(() => runServiceCommand(commandName));
+        .description(`${commandName[0]?.toUpperCase()}${commandName.slice(1)} Nessie.`)
+        .action(async () => commandName === "status" ? status() : printIfPresent(await service(commandName)));
 }
-await program.parseAsync();
+function printIfPresent(message) {
+    if (message.length > 0)
+        console.log(message);
+}
+// Node 26 can warn about unsettled top-level await while command actions are
+// waiting on the runtime; keep the process alive until commander settles.
+const keepAlive = setTimeout(() => undefined, 2 ** 31 - 1);
+program
+    .parseAsync()
+    .catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+})
+    .finally(() => clearTimeout(keepAlive));

package/dist/commands/auth.js

@@ -0,0 +1,116 @@
+import { hostname } from "node:os";
+import { AuthStatus, beginSignIn, getAuthState, setApiKey, signOut, startDevicePairing, switchAccount } from "../nera/client.js";
+import { ensureRuntime } from "../nera/process.js";
+import { openBrowser } from "../platform/openBrowser.js";
+import { renderTabTable } from "../platform/table.js";
+import { billingLines } from "./status.js";
+export function registerAuthCommands(program) {
+    const auth = program.command("auth").description("Manage Nessie sign-in.");
+    auth.command("status").description("Show signed-in accounts.").action(authStatus);
+    auth
+        .command("login")
+        .description("Sign in to Nessie.")
+        .option("--api-key <key>", "Use a Nessie API key for non-interactive headless setup.")
+        .option("--pair", "Use device pairing instead of browser sign-in.")
+        .option("--no-open", "Print the browser sign-in URL instead of opening it.")
+        .action(authLogin);
+    auth.command("switch <user-id>").description("Switch active account.").action(authSwitch);
+    auth.command("logout [user-id]").description("Sign out the active account or a specific account.").action(authLogout);
+}
+async function authStatus() {
+    const runtime = await ensureRuntime({ detached: true });
+    const auth = await getAuthState(runtime);
+    const accounts = auth.accounts ?? [];
+    if (accounts.length === 0) {
+        console.log("Not signed in.");
+        return;
+    }
+    const rows = [
+        ["ACTIVE", "EMAIL", "ID"],
+        ...accounts.map((account) => [account.id === auth.user?.id ? "*" : "", account.email, account.id]),
+    ];
+    const colors = [
+        ["bold", "bold", "bold"],
+        ...accounts.map((account) => [account.id === auth.user?.id ? "green" : "dim", undefined, "dim"]),
+    ];
+    process.stdout.write(renderTabTable(rows, colors));
+    for (const line of billingLines(auth.billing))
+        console.log(line);
+}
+async function authLogin(options) {
+    if (options.apiKey !== undefined && options.pair === true)
+        throw new Error("--api-key and --pair cannot be used together.");
+    if (options.apiKey !== undefined && !options.apiKey.trim())
+        throw new Error("--api-key cannot be empty.");
+    const runtime = await ensureRuntime({ detached: true });
+    if (options.apiKey !== undefined) {
+        const apiKey = options.apiKey.trim();
+        await setApiKey(runtime, apiKey);
+    }
+    else if (options.pair === true) {
+        await authPair(runtime);
+        return;
+    }
+    else {
+        const beforeAuth = await getAuthState(runtime);
+        if (beforeAuth.status !== AuthStatus.SIGNED_IN) {
+            const { url } = await beginSignIn(runtime);
+            if (options.open === false)
+                console.log(`Open this URL to sign in: ${url}`);
+            else {
+                await openBrowser(url);
+                console.log("Opened browser sign-in.");
+            }
+            await waitForSignIn(runtime, beforeAuth);
+        }
+    }
+    let auth = await getAuthState(runtime);
+    if (auth.user?.email)
+        console.log(`Signed in as ${auth.user.email}.`);
+    // The billing refresh is fired async on install; give it a bounded
+    // moment to land so login can report the plan. Silence is fine if the
+    // fetch is slow - `nessie-daemon status` shows it later.
+    const deadline = Date.now() + 3000;
+    while (!auth.billing?.tier && Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, 250));
+        auth = await getAuthState(runtime);
+    }
+    for (const line of billingLines(auth.billing))
+        console.log(line);
+}
+async function authPair(runtime) {
+    const pairing = await startDevicePairing(runtime, hostname());
+    console.log(`Enter code ${pairing.userCode} in Nessie.`);
+    if (pairing.verificationHint)
+        console.log(pairing.verificationHint);
+    if (pairing.expiresAt)
+        console.log(`Expires at ${pairing.expiresAt}.`);
+}
+async function authSwitch(userId) {
+    const runtime = await ensureRuntime({ detached: true });
+    const auth = await switchAccount(runtime, userId);
+    if (auth.user?.email)
+        console.log(`Switched to ${auth.user.email}.`);
+}
+async function authLogout(userId) {
+    const runtime = await ensureRuntime({ detached: true });
+    const auth = await signOut(runtime, userId);
+    if (auth.user?.email)
+        console.log(`Signed in as ${auth.user.email}.`);
+    else
+        console.log("Signed out.");
+}
+async function waitForSignIn(runtime, beforeAuth) {
+    const beforeAccountIds = new Set((beforeAuth.accounts ?? []).map((account) => account.id));
+    const alreadySignedIn = beforeAuth.status === AuthStatus.SIGNED_IN || beforeAuth.status === AuthStatus.REAUTH_REQUIRED;
+    const deadline = Date.now() + 5 * 60 * 1000;
+    while (Date.now() < deadline) {
+        const state = await getAuthState(runtime);
+        const signedIn = state.status === AuthStatus.SIGNED_IN || state.status === AuthStatus.REAUTH_REQUIRED;
+        const hasNewAccount = (state.accounts ?? []).some((account) => !beforeAccountIds.has(account.id));
+        if (signedIn && (!alreadySignedIn || hasNewAccount || state.user?.id !== beforeAuth.user?.id || state.status !== beforeAuth.status))
+            return;
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+    throw new Error("Timed out waiting for browser sign-in.");
+}

package/dist/commands/integrations.js

@@ -0,0 +1,84 @@
+import { addSource, configureSource, discoverSources, listSources, removeSource, startIngestion, stopIngestion, triggerIngestion } from "../nera/client.js";
+import { ensureRuntime } from "../nera/process.js";
+import { renderTabTable } from "../platform/table.js";
+export function registerIntegrationCommands(program) {
+    const integrations = program.command("integrations").description("Manage local data integrations.");
+    integrations.command("list").alias("ls").description("List configured integrations.").action(listIntegrations);
+    integrations.command("discover").description("Discover available local integrations.").action(discoverIntegrations);
+    integrations
+        .command("add <kind>")
+        .description("Add an integration.")
+        .option("--path <path>", "Override the default local path.")
+        .option("--disabled", "Add without enabling automatic ingestion.")
+        .action(addIntegration);
+    integrations.command("enable <source-id>").description("Enable automatic ingestion for an integration.").action((sourceId) => setEnabled(sourceId, true));
+    integrations.command("disable <source-id>").description("Disable automatic ingestion for an integration.").action((sourceId) => setEnabled(sourceId, false));
+    integrations.command("remove <source-id>").description("Remove an integration.").action(removeIntegration);
+    integrations.command("run").description("Run ingestion once.").action(runIngestion);
+    integrations.command("start").description("Enable automatic ingestion for all integrations.").action(startAutomaticIngestion);
+    integrations.command("stop").description("Disable automatic ingestion for all integrations.").action(stopAutomaticIngestion);
+}
+async function listIntegrations() {
+    const runtime = await ensureRuntime({ detached: true });
+    const { sources } = await listSources(runtime);
+    if (sources.length === 0) {
+        console.log("No integrations configured.");
+        return;
+    }
+    const rows = [
+        ["ID", "NAME", "STATUS", "PATH"],
+        ...sources.map((source) => [source.sourceId, source.displayName, source.enabled ? "enabled" : "disabled", source.basePath]),
+    ];
+    const colors = [
+        ["bold", "bold", "bold", "bold"],
+        ...sources.map((source) => ["dim", undefined, source.enabled ? "green" : "yellow", "cyan"]),
+    ];
+    process.stdout.write(renderTabTable(rows, colors));
+}
+async function discoverIntegrations() {
+    const runtime = await ensureRuntime({ detached: true });
+    const { sources } = await discoverSources(runtime);
+    if (sources.length === 0) {
+        console.log("No local integrations found.");
+        return;
+    }
+    const rows = [
+        ["KIND", "NAME", "STATUS", "PATH"],
+        ...sources.map((source) => [source.kind, source.displayName, source.alreadyAdded ? "configured" : "available", source.basePath]),
+    ];
+    const colors = [
+        ["bold", "bold", "bold", "bold"],
+        ...sources.map((source) => ["dim", undefined, source.alreadyAdded ? "green" : "yellow", "cyan"]),
+    ];
+    process.stdout.write(renderTabTable(rows, colors));
+}
+async function addIntegration(kind, options) {
+    const runtime = await ensureRuntime({ detached: true });
+    const source = await addSource(runtime, kind, options.path ?? "", options.disabled !== true, false);
+    console.log(`Added ${source.displayName}.`);
+}
+async function setEnabled(sourceId, enabled) {
+    const runtime = await ensureRuntime({ detached: true });
+    const source = await configureSource(runtime, sourceId, enabled);
+    console.log(`${enabled ? "Enabled" : "Disabled"} ${source.displayName}.`);
+}
+async function removeIntegration(sourceId) {
+    const runtime = await ensureRuntime({ detached: true });
+    await removeSource(runtime, sourceId);
+    console.log("Removed integration.");
+}
+async function runIngestion() {
+    const runtime = await ensureRuntime({ detached: true });
+    const result = await triggerIngestion(runtime);
+    console.log(`Ran ingestion for ${result.sourceIds.length} integration(s).`);
+}
+async function startAutomaticIngestion() {
+    const runtime = await ensureRuntime({ detached: true });
+    await startIngestion(runtime);
+    console.log("Automatic ingestion enabled.");
+}
+async function stopAutomaticIngestion() {
+    const runtime = await ensureRuntime({ detached: true });
+    await stopIngestion(runtime);
+    console.log("Automatic ingestion disabled.");
+}

package/dist/commands/login.js

@@ -0,0 +1,145 @@
+import { checkbox, confirm } from "@inquirer/prompts";
+import { hostname } from "node:os";
+import { addSource, AuthStatus, beginSignIn, discoverSources, getAuthState, listSources, listTeamInvites, respondToTeamInvite, setApiKey, startCloudSync, startIngestion } from "../nera/client.js";
+import { ensureRuntime } from "../nera/process.js";
+import { openBrowser } from "../platform/openBrowser.js";
+import { service } from "./service.js";
+import { enableCloudSyncForTeam } from "./teams.js";
+import { applyTeamPoliciesForRuntime } from "./sharing.js";
+export async function login(options) {
+    const runtime = await ensureRuntime({ detached: true });
+    if (runtime.started)
+        console.log("Started Nessie.");
+    const nonInteractive = options.apiKey !== undefined;
+    if (options.apiKey !== undefined) {
+        const apiKey = options.apiKey.trim();
+        if (!apiKey)
+            throw new Error("--api-key cannot be empty.");
+        await setApiKey(runtime, apiKey);
+    }
+    else {
+        const beforeAuth = await getAuthState(runtime);
+        if (beforeAuth.status !== AuthStatus.SIGNED_IN) {
+            const { url } = await beginSignIn(runtime);
+            if (options.open === false) {
+                console.log(`Open this URL to sign in: ${url}`);
+            }
+            else {
+                await openBrowser(url);
+                console.log("Opened browser sign-in.");
+            }
+            await waitForSignIn(runtime, beforeAuth);
+        }
+    }
+    const auth = await getAuthState(runtime);
+    if (auth.status !== AuthStatus.SIGNED_IN && auth.status !== AuthStatus.REAUTH_REQUIRED) {
+        throw new Error("Sign-in did not complete.");
+    }
+    if (auth.user?.email)
+        console.log(`Signed in as ${auth.user.email}.`);
+    if (!nonInteractive)
+        await handleTeamInvites(runtime);
+    await configureSources(runtime, { nonInteractive });
+    await startIngestion(runtime);
+    let cloudSyncStarted = false;
+    try {
+        await startCloudSync(runtime);
+        cloudSyncStarted = true;
+    }
+    catch (error) {
+        console.log(`Cloud sync was not started: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!nonInteractive && cloudSyncStarted) {
+        try {
+            await applyTeamPoliciesForRuntime(runtime, { quietNoop: true, retrySyncMetadata: true });
+        }
+        catch {
+            console.log("Team sharing policies were not applied yet. Run `nessie-daemon sharing apply-team-policies` to try again.");
+        }
+    }
+    const backgroundStarted = options.background !== false;
+    if (backgroundStarted) {
+        await service("start", { quiet: true });
+    }
+    console.log(successLine(backgroundStarted
+        ? "🎉 Nessie is set up successfully. It will run in the background to sync your integrations."
+        : "🎉 Nessie is set up successfully."));
+}
+function successLine(message) {
+    return process.stdout.isTTY ? `\x1b[32m${message}\x1b[0m` : message;
+}
+async function waitForSignIn(runtime, beforeAuth) {
+    const beforeAccountIds = new Set((beforeAuth.accounts ?? []).map((account) => account.id));
+    const alreadySignedIn = beforeAuth.status === AuthStatus.SIGNED_IN || beforeAuth.status === AuthStatus.REAUTH_REQUIRED;
+    const deadline = Date.now() + 5 * 60 * 1000;
+    while (Date.now() < deadline) {
+        const state = await getAuthState(runtime);
+        const signedIn = state.status === AuthStatus.SIGNED_IN || state.status === AuthStatus.REAUTH_REQUIRED;
+        const hasNewAccount = (state.accounts ?? []).some((account) => !beforeAccountIds.has(account.id));
+        if (signedIn && (!alreadySignedIn || hasNewAccount || state.user?.id !== beforeAuth.user?.id || state.status !== beforeAuth.status))
+            return;
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+    throw new Error("Timed out waiting for browser sign-in.");
+}
+async function handleTeamInvites(runtime) {
+    const { invites } = await listTeamInvites(runtime);
+    let joinedTeamId;
+    for (const invite of invites) {
+        const accepted = await confirm({
+            message: `Join ${invite.teamName} on Nessie?`,
+            default: true,
+        });
+        await respondToTeamInvite(runtime, invite.teamId, accepted);
+        console.log(accepted ? `Joined ${invite.teamName}.` : `Declined ${invite.teamName}.`);
+        if (accepted)
+            joinedTeamId = invite.teamId;
+    }
+    // Teams share through Nessie Cloud, so joining one opts the account in;
+    // without this a daemon-only member can never sync (the account flag is
+    // latched by a first preflight the daemon otherwise refuses to run).
+    if (joinedTeamId !== undefined)
+        await enableCloudSyncForTeam(runtime, joinedTeamId);
+}
+async function configureSources(runtime, options) {
+    const [{ sources }, existingSources] = await Promise.all([discoverSources(runtime), listSources(runtime)]);
+    const enabledSources = new Set(existingSources.sources.filter((source) => source.enabled).map((source) => `${source.kind}:${source.basePath}`));
+    if (sources.length === 0) {
+        console.log("No supported local data integrations were found.");
+        return;
+    }
+    const selected = options.nonInteractive
+        ? sources
+        : await selectSources(sources, enabledSources);
+    // Already-enabled sources are a no-op; re-asserting them costs one RPC
+    // each, which the ingest-all fast path would otherwise pay on every re-run.
+    const changed = selected.filter((source) => !enabledSources.has(`${source.kind}:${source.basePath}`));
+    for (const source of changed) {
+        await addSource(runtime, source.kind, source.basePath, true, source.alreadyAdded);
+    }
+    const alreadyEnabled = selected.length - changed.length;
+    console.log(alreadyEnabled > 0
+        ? `Enabled ${changed.length} integration(s) (${alreadyEnabled} already enabled).`
+        : `Enabled ${changed.length} integration(s).`);
+}
+/** Fast path first: ingest everything detected; the checkbox is opt-in friction. */
+async function selectSources(sources, enabledSources) {
+    for (const source of sources) {
+        console.log(`  - ${source.displayName} (${source.basePath})`);
+    }
+    const ingestAll = await confirm({
+        message: `Ingest all ${sources.length} detected integration(s) from ${hostname()}?`,
+        default: true,
+    });
+    if (ingestAll)
+        return sources;
+    return checkbox({
+        message: "Choose integrations to ingest:",
+        choices: sources.map((source) => ({
+            name: `${source.displayName} (${source.basePath})`,
+            value: source,
+            checked: enabledSources.has(`${source.kind}:${source.basePath}`),
+        })),
+        required: true,
+    });
+}

package/dist/commands/run.js

@@ -1,10 +1,25 @@
-import { runSyncLoop, runSyncOnce } from "../sync/loop.js";
-export async function runDaemon(options) {
+import { ensureRuntime } from "../nera/process.js";
+import { startCloudSync, startIngestion, triggerCloudSync, triggerIngestion } from "../nera/client.js";
+export async function run(options) {
     if (options.once) {
-        const result = await runSyncOnce();
-        console.log(`Synced ${result.nodes} nodes and ${result.edges} edges.`);
+        const runtime = await ensureRuntime({ detached: true });
+        const result = await triggerIngestion(runtime);
+        const cloudSyncQueued = await tryCloudSync(() => triggerCloudSync(runtime));
+        console.log(`Triggered Nessie ingestion for ${result.sourceIds.length} integration(s)${cloudSyncQueued ? " and queued cloud sync" : ""}.`);
         return;
     }
-    const intervalSeconds = Number.parseInt(options.intervalSeconds ?? "60", 10);
-    await runSyncLoop(Number.isFinite(intervalSeconds) ? intervalSeconds : 60);
+    const runtime = await ensureRuntime({ detached: true });
+    await startIngestion(runtime);
+    await tryCloudSync(() => startCloudSync(runtime));
+    console.log(runtime.started ? "Started Nessie." : "Nessie is already running.");
+}
+async function tryCloudSync(action) {
+    try {
+        await action();
+        return true;
+    }
+    catch (error) {
+        console.log(`Cloud sync was not started: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
 }

package/dist/commands/service.js

@@ -1,45 +1,27 @@
-import { readConfig } from "../config/store.js";
-import { backgroundDaemonStatus, startBackgroundDaemon, stopBackgroundDaemon } from "../service/process.js";
-import { systemctl } from "../service/systemd.js";
-const defaultServiceDeps = {
-    backgroundDaemonStatus,
-    startBackgroundDaemon,
-    stopBackgroundDaemon,
-    systemctl,
-    readConfig,
-};
-export async function runServiceCommand(command, options = {}, depsOverride = {}) {
-    const deps = { ...defaultServiceDeps, ...depsOverride };
-    if (command === "start" && await shouldStartBackground(options, deps)) {
-        console.log(await deps.startBackgroundDaemon());
-        return;
+import { startCloudSync, startIngestion } from "../nera/client.js";
+import { ensureRuntime, probeRuntime, stopRuntime } from "../nera/process.js";
+export async function service(command, options = {}) {
+    if (command === "start") {
+        const runtime = await ensureRuntime({ detached: true });
+        await startIngestion(runtime);
+        await tryCloudSync(() => startCloudSync(runtime), options.quiet);
+        return "";
     }
     if (command === "stop") {
-        const status = await deps.backgroundDaemonStatus();
-        if (status !== null) {
-            console.log(await deps.stopBackgroundDaemon());
-            return;
-        }
+        const stopped = await stopRuntime();
+        return stopped ? "Stopped Nessie." : "Nessie is not running.";
     }
-    if (command === "status") {
-        const status = await deps.backgroundDaemonStatus();
-        if (status !== null) {
-            console.log(status);
-            return;
-        }
-    }
-    const output = await deps.systemctl(command, "nessie-daemon.service");
-    if (output.trim())
-        console.log(output.trim());
+    const runtime = await probeRuntime();
+    return runtime ? "Nessie is running." : "Nessie is not running.";
 }
-async function shouldStartBackground(options, deps) {
-    if (options.background)
-        return true;
+async function tryCloudSync(action, quiet) {
     try {
-        const config = await deps.readConfig();
-        return Boolean(config.apiKey);
+        await action();
+        return true;
     }
-    catch {
+    catch (error) {
+        if (!quiet)
+            console.log(`Cloud sync was not started: ${error instanceof Error ? error.message : String(error)}`);
         return false;
     }
 }