@nessielabs/daemon 0.1.0 → 0.2.0

package/dist/cli.js

@@ -7,12 +7,13 @@ const program = new Command();
 program
     .name("nessie-daemon")
     .description("Headless Nessie ingestion daemon for Linux agent machines.")
-    .version("0.1.0");
+    .version("0.2.0");
 program
     .command("setup")
     .description("Authenticate, select local sources, and optionally install the user systemd service.")
     .option("--api-url <url>", "Nessie sync API URL")
     .option("--auth-api-url <url>", "Nessie auth API URL")
+    .option("--api-key <key>", "Use a Nessie API key for non-interactive headless setup.")
     .action(runSetup);
 program
     .command("run")
@@ -20,10 +21,15 @@ program
     .option("--once", "Run one sync pass and exit.")
     .option("--interval-seconds <seconds>", "Seconds between sync passes.", "60")
     .action(runDaemon);
-for (const commandName of ["start", "stop", "status"]) {
+program
+    .command("start")
+    .description("Start the daemon.")
+    .option("--background", "Start as a detached background process without systemd.")
+    .action((options) => runServiceCommand("start", options));
+for (const commandName of ["stop", "status"]) {
     program
         .command(commandName)
-        .description(`${commandName[0]?.toUpperCase()}${commandName.slice(1)} the user systemd service.`)
+        .description(`${commandName[0]?.toUpperCase()}${commandName.slice(1)} the daemon.`)
         .action(() => runServiceCommand(commandName));
 }
 await program.parseAsync();

package/dist/commands/service.js

@@ -1,6 +1,45 @@
+import { readConfig } from "../config/store.js";
+import { backgroundDaemonStatus, startBackgroundDaemon, stopBackgroundDaemon } from "../service/process.js";
 import { systemctl } from "../service/systemd.js";
-export async function runServiceCommand(command) {
-    const output = await systemctl(command, "nessie-daemon.service");
+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;
+    }
+    if (command === "stop") {
+        const status = await deps.backgroundDaemonStatus();
+        if (status !== null) {
+            console.log(await deps.stopBackgroundDaemon());
+            return;
+        }
+    }
+    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());
 }
+async function shouldStartBackground(options, deps) {
+    if (options.background)
+        return true;
+    try {
+        const config = await deps.readConfig();
+        return Boolean(config.apiKey);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/commands/setup.js

@@ -5,12 +5,23 @@ import { getDaemonPaths } from "../config/paths.js";
 import { createConfig, createInitialState, defaultApiUrl, defaultAuthApiUrl, writeConfig, writeState } from "../config/store.js";
 import { installUserService } from "../service/systemd.js";
 import { detectSources } from "../sources/detect.js";
-export async function runSetup(options) {
+export async function runSetup(options, depsOverride = {}) {
+    const deps = resolveSetupDeps(depsOverride);
     const apiUrl = options.apiUrl ?? defaultApiUrl;
     const authApiUrl = options.authApiUrl ?? defaultAuthApiUrl;
     const deviceName = hostname();
+    if (options.apiKey !== undefined) {
+        await runAPIKeySetup({
+            apiKey: options.apiKey,
+            apiUrl,
+            authApiUrl,
+            deviceName,
+            deps,
+        });
+        return;
+    }
     const auth = await runDeviceAuth({ authApiUrl, deviceName });
-    const detectedSources = await detectSources();
+    const detectedSources = await deps.detectSources();
     if (detectedSources.length === 0) {
         throw new Error("No supported Codex or Claude Code history directories were found.");
     }
@@ -23,7 +34,6 @@ export async function runSetup(options) {
         })),
         required: true,
     });
-    const paths = getDaemonPaths();
     const config = createConfig({
         accessToken: auth.accessToken,
         refreshToken: auth.refreshToken,
@@ -33,11 +43,44 @@ export async function runSetup(options) {
         authApiUrl,
         selectedSources,
     });
-    await writeConfig(config, paths);
-    await writeState(createInitialState(), paths);
-    console.log(`Saved config to ${paths.configFile}`);
+    await deps.writeConfig(config, deps.paths);
+    await deps.writeState(createInitialState(), deps.paths);
+    console.log(`Saved config to ${deps.paths.configFile}`);
     if (await confirm({ message: "Install and start the user systemd service?", default: true })) {
-        await installUserService(paths);
+        await installUserService(deps.paths);
         console.log("Installed and started nessie-daemon.service");
     }
 }
+async function runAPIKeySetup(input) {
+    const apiKey = input.apiKey.trim();
+    if (!apiKey)
+        throw new Error("--api-key cannot be empty.");
+    const detectedSources = await input.deps.detectSources();
+    if (detectedSources.length === 0) {
+        throw new Error("No supported Codex or Claude Code history directories were found.");
+    }
+    const config = createConfig({
+        apiKey,
+        deviceName: input.deviceName,
+        apiUrl: input.apiUrl,
+        authApiUrl: input.authApiUrl,
+        selectedSources: detectedSources,
+    });
+    await input.deps.writeConfig(config, input.deps.paths);
+    await input.deps.writeState(createInitialState(), input.deps.paths);
+    console.log("Configured Nessie daemon with API key auth.");
+    console.log(`Selected ${detectedSources.length} source(s):`);
+    for (const source of detectedSources) {
+        console.log(`- ${source.displayName} (${source.basePath})`);
+    }
+    console.log(`Saved config to ${input.deps.paths.configFile}`);
+    console.log("Run `nessie-daemon start` to start syncing.");
+}
+function resolveSetupDeps(overrides) {
+    return {
+        detectSources: overrides.detectSources ?? detectSources,
+        writeConfig: overrides.writeConfig ?? writeConfig,
+        writeState: overrides.writeState ?? writeState,
+        paths: overrides.paths ?? getDaemonPaths(),
+    };
+}

package/dist/config/paths.js

@@ -11,6 +11,8 @@ export function getDaemonPaths(env = process.env, home = homedir()) {
         stateDir,
         configFile: join(configDir, "config.json"),
         stateFile: join(stateDir, "state.json"),
+        pidFile: join(stateDir, "daemon.pid"),
+        logFile: join(stateDir, "daemon.log"),
         systemdUserDir,
         systemdServiceFile: join(systemdUserDir, "nessie-daemon.service"),
     };

package/dist/config/store.js

@@ -14,6 +14,7 @@ export function createConfig(input) {
         deviceName: input.deviceName ?? hostname(),
         accessToken: input.accessToken,
         refreshToken: input.refreshToken ?? null,
+        apiKey: input.apiKey ?? null,
         selectedSources: input.selectedSources.map((source) => ({
             ...source,
             localId: randomUUID(),

package/dist/service/process.js

@@ -0,0 +1,134 @@
+import { spawn } from "node:child_process";
+import { closeSync, openSync } from "node:fs";
+import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { getDaemonPaths } from "../config/paths.js";
+const defaultProcessDeps = {
+    spawn,
+    argv: process.argv,
+    execPath: process.execPath,
+    kill: process.kill,
+    readProcessCmdline,
+};
+export async function startBackgroundDaemon(paths = getDaemonPaths(), depsOverride = {}) {
+    const deps = resolveProcessDeps(depsOverride);
+    const existingPid = await readPid(paths);
+    if (existingPid && await isDaemonRunning(existingPid, deps)) {
+        return `nessie-daemon is already running with pid ${existingPid}.`;
+    }
+    if (existingPid)
+        await removePid(paths);
+    await mkdir(paths.stateDir, { recursive: true });
+    if (!await reservePidFile(paths))
+        return "nessie-daemon is already starting.";
+    const out = openSync(paths.logFile, "a");
+    const err = openSync(paths.logFile, "a");
+    let child;
+    try {
+        child = deps.spawn(deps.execPath, [cliPath(deps.argv), "run"], {
+            detached: true,
+            stdio: ["ignore", out, err],
+        });
+        child.unref();
+    }
+    finally {
+        closeSync(out);
+        closeSync(err);
+    }
+    if (!child.pid) {
+        await removePid(paths);
+        throw new Error("Failed to start nessie-daemon in background.");
+    }
+    await writeFile(paths.pidFile, `${child.pid}\n`, { mode: 0o600 });
+    return `Started nessie-daemon with pid ${child.pid}. Logs: ${paths.logFile}`;
+}
+export async function stopBackgroundDaemon(paths = getDaemonPaths(), depsOverride = {}) {
+    const deps = resolveProcessDeps(depsOverride);
+    const pid = await readPid(paths);
+    if (!pid)
+        return "nessie-daemon is not running.";
+    if (!await isDaemonRunning(pid, deps)) {
+        await removePid(paths);
+        return "nessie-daemon is not running.";
+    }
+    deps.kill(pid, "SIGTERM");
+    await removePid(paths);
+    return `Stopped nessie-daemon with pid ${pid}.`;
+}
+export async function backgroundDaemonStatus(paths = getDaemonPaths(), depsOverride = {}) {
+    const deps = resolveProcessDeps(depsOverride);
+    const pid = await readPid(paths);
+    if (!pid)
+        return null;
+    if (!await isDaemonRunning(pid, deps)) {
+        await removePid(paths);
+        return "nessie-daemon is not running.";
+    }
+    return `nessie-daemon is running with pid ${pid}. Logs: ${paths.logFile}`;
+}
+async function readPid(paths) {
+    try {
+        const raw = await readFile(paths.pidFile, "utf8");
+        const pid = Number.parseInt(raw.trim(), 10);
+        return Number.isFinite(pid) && pid > 0 ? pid : null;
+    }
+    catch (error) {
+        if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+async function removePid(paths) {
+    try {
+        await unlink(paths.pidFile);
+    }
+    catch (error) {
+        if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT")
+            return;
+        throw error;
+    }
+}
+async function reservePidFile(paths) {
+    try {
+        await writeFile(paths.pidFile, "starting\n", { mode: 0o600, flag: "wx" });
+        return true;
+    }
+    catch (error) {
+        if (typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST")
+            return false;
+        throw error;
+    }
+}
+async function isDaemonRunning(pid, deps) {
+    try {
+        deps.kill(pid, 0);
+    }
+    catch {
+        return false;
+    }
+    const cmdline = await deps.readProcessCmdline(pid);
+    if (cmdline === null)
+        return false;
+    return cmdline.includes(cliPath(deps.argv)) && cmdline.includes(" run");
+}
+async function readProcessCmdline(pid) {
+    try {
+        const raw = await readFile(`/proc/${pid}/cmdline`);
+        const cmdline = raw.toString("utf8").replace(/\0/g, " ").trim();
+        return cmdline || null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveProcessDeps(overrides) {
+    return {
+        ...defaultProcessDeps,
+        ...overrides,
+    };
+}
+function cliPath(argv) {
+    const path = argv[1];
+    if (!path)
+        throw new Error("Cannot determine nessie-daemon CLI path.");
+    return path;
+}

package/dist/sync/client.js

@@ -22,16 +22,25 @@ export async function pushSyncPayload(config, payload, options = {}) {
     }, options);
 }
 async function postJsonWithRefresh(config, path, body, options) {
+    const token = authToken(config);
     try {
-        await postJson(config.apiUrl, path, body, { token: config.accessToken, fetchImpl: options.fetchImpl });
+        await postJson(config.apiUrl, path, body, { token, fetchImpl: options.fetchImpl });
         return config;
     }
     catch (error) {
+        if (config.apiKey)
+            throw error;
         if (!(error instanceof ApiError) || error.status !== 401)
             throw error;
     }
     const refreshed = await refreshAccessToken(config, { fetchImpl: options.fetchImpl });
     await (options.persistConfig ?? writeConfig)(refreshed);
-    await postJson(refreshed.apiUrl, path, body, { token: refreshed.accessToken, fetchImpl: options.fetchImpl });
+    await postJson(refreshed.apiUrl, path, body, { token: authToken(refreshed), fetchImpl: options.fetchImpl });
     return refreshed;
 }
+function authToken(config) {
+    const token = config.apiKey ?? config.accessToken;
+    if (!token)
+        throw new Error("Daemon config is missing auth credentials. Run nessie-daemon setup.");
+    return token;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nessielabs/daemon",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Headless Linux ingestion daemon for Nessie agent traces.",
   "license": "UNLICENSED",
   "type": "module",