@nessielabs/daemon 0.2.0 → 0.2.2

package/README.md

@@ -11,10 +11,11 @@ nessie-daemon setup
 
 `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.
 
-Use non-production endpoints with:
+For non-interactive headless setup, pass a Nessie API key:
 
 ```bash
-nessie-daemon setup --api-url https://sync.example --auth-api-url https://auth.example
+nessie-daemon setup --api-key "$NESSIE_API_KEY"
+nessie-daemon start
 ```
 
 ## Commands

package/dist/auth/deviceFlow.js

@@ -1,10 +1,11 @@
 import { setTimeout as sleep } from "node:timers/promises";
 import { postJson } from "../api/http.js";
+import { authApiUrl } from "../config/endpoints.js";
 export async function runDeviceAuth(input) {
     const log = input.log ?? console;
     const fetchImpl = input.fetchImpl ?? fetch;
     const sleepMs = input.sleepMs ?? sleep;
-    const start = await postJson(input.authApiUrl, "/auth/device/start", {
+    const start = await postJson(authApiUrl, "/auth/device/start", {
         device_name: input.deviceName,
         platform: "linux",
     }, { fetchImpl });
@@ -13,7 +14,7 @@ export async function runDeviceAuth(input) {
     const expiresAt = Date.now() + Math.max(60, start.expires_in ?? 600) * 1000;
     while (Date.now() < expiresAt) {
         await sleepMs(intervalMs);
-        const poll = await postJson(input.authApiUrl, "/auth/device/poll", {
+        const poll = await postJson(authApiUrl, "/auth/device/poll", {
             device_code: start.device_code,
         }, { fetchImpl });
         if (poll.status === "pending")

package/dist/auth/tokens.js

@@ -1,4 +1,5 @@
 import { ApiError, postJson } from "../api/http.js";
+import { authApiUrl } from "../config/endpoints.js";
 export class AuthRefreshError extends Error {
 }
 export async function refreshAccessToken(config, options = {}) {
@@ -6,7 +7,7 @@ export async function refreshAccessToken(config, options = {}) {
         throw new AuthRefreshError("Access token expired and no refresh token is configured.");
     }
     try {
-        const response = await postJson(config.authApiUrl, "/auth/refresh", {
+        const response = await postJson(authApiUrl, "/auth/refresh", {
             refresh_token: config.refreshToken,
         }, { fetchImpl: options.fetchImpl });
         if (!response.access_token) {

package/dist/cli.js

@@ -7,12 +7,10 @@ const program = new Command();
 program
     .name("nessie-daemon")
     .description("Headless Nessie ingestion daemon for Linux agent machines.")
-    .version("0.2.0");
+    .version("0.2.2");
 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

package/dist/commands/setup.js

@@ -2,25 +2,21 @@ import { checkbox, confirm } from "@inquirer/prompts";
 import { hostname } from "node:os";
 import { runDeviceAuth } from "../auth/deviceFlow.js";
 import { getDaemonPaths } from "../config/paths.js";
-import { createConfig, createInitialState, defaultApiUrl, defaultAuthApiUrl, writeConfig, writeState } from "../config/store.js";
+import { createConfig, createInitialState, writeConfig, writeState } from "../config/store.js";
 import { installUserService } from "../service/systemd.js";
 import { detectSources } from "../sources/detect.js";
 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 auth = await runDeviceAuth({ deviceName });
     const detectedSources = await deps.detectSources();
     if (detectedSources.length === 0) {
         throw new Error("No supported Codex or Claude Code history directories were found.");
@@ -39,8 +35,6 @@ export async function runSetup(options, depsOverride = {}) {
         refreshToken: auth.refreshToken,
         deviceId: auth.deviceId,
         deviceName,
-        apiUrl,
-        authApiUrl,
         selectedSources,
     });
     await deps.writeConfig(config, deps.paths);
@@ -62,8 +56,6 @@ async function runAPIKeySetup(input) {
     const config = createConfig({
         apiKey,
         deviceName: input.deviceName,
-        apiUrl: input.apiUrl,
-        authApiUrl: input.authApiUrl,
         selectedSources: detectedSources,
     });
     await input.deps.writeConfig(config, input.deps.paths);

package/dist/config/endpoints.js

@@ -0,0 +1,2 @@
+export const syncApiUrl = "https://nessie-codebase-843813578359.us-west1.run.app";
+export const authApiUrl = "https://nessie-notes-go-843813578359.us-west1.run.app";

package/dist/config/store.js

@@ -3,13 +3,9 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { hostname } from "node:os";
 import { dirname } from "node:path";
 import { getDaemonPaths } from "./paths.js";
-export const defaultApiUrl = "https://nessie-codebase-843813578359.us-west1.run.app";
-export const defaultAuthApiUrl = "https://nessie-notes-go-843813578359.us-west1.run.app";
 export function createConfig(input) {
     const deviceId = input.deviceId ?? randomUUID();
     return {
-        apiUrl: input.apiUrl ?? defaultApiUrl,
-        authApiUrl: input.authApiUrl ?? defaultAuthApiUrl,
         deviceId,
         deviceName: input.deviceName ?? hostname(),
         accessToken: input.accessToken,
@@ -26,6 +22,7 @@ export function createInitialState() {
     return {
         files: {},
         pushedSourceRootIds: [],
+        pushedSessions: {},
         lastSyncAt: null,
     };
 }
@@ -42,6 +39,7 @@ export async function readState(paths = getDaemonPaths()) {
         return {
             files: parsed.files ?? {},
             pushedSourceRootIds: parsed.pushedSourceRootIds ?? [],
+            pushedSessions: parsed.pushedSessions ?? {},
             lastSyncAt: parsed.lastSyncAt ?? null,
         };
     }

package/dist/sync/client.js

@@ -1,5 +1,6 @@
 import { ApiError, postJson } from "../api/http.js";
 import { refreshAccessToken } from "../auth/tokens.js";
+import { syncApiUrl } from "../config/endpoints.js";
 import { writeConfig } from "../config/store.js";
 export async function runPreflightV3(config, options = {}) {
     return postJsonWithRefresh(config, "/sync/v3/preflight", {
@@ -24,7 +25,7 @@ export async function pushSyncPayload(config, payload, options = {}) {
 async function postJsonWithRefresh(config, path, body, options) {
     const token = authToken(config);
     try {
-        await postJson(config.apiUrl, path, body, { token, fetchImpl: options.fetchImpl });
+        await postJson(syncApiUrl, path, body, { token, fetchImpl: options.fetchImpl });
         return config;
     }
     catch (error) {
@@ -35,7 +36,7 @@ async function postJsonWithRefresh(config, path, body, options) {
     }
     const refreshed = await refreshAccessToken(config, { fetchImpl: options.fetchImpl });
     await (options.persistConfig ?? writeConfig)(refreshed);
-    await postJson(refreshed.apiUrl, path, body, { token: authToken(refreshed), fetchImpl: options.fetchImpl });
+    await postJson(syncApiUrl, path, body, { token: authToken(refreshed), fetchImpl: options.fetchImpl });
     return refreshed;
 }
 function authToken(config) {

package/dist/sync/loop.js

@@ -13,14 +13,19 @@ export async function runSyncOnce() {
     const edges = [];
     const previouslyPushedRoots = new Set(state.pushedSourceRootIds);
     const pushedSourceRootIds = new Set(previouslyPushedRoots);
+    const pushedSessions = { ...state.pushedSessions };
     for (const source of config.selectedSources) {
         const sessions = scan.sessionsBySourceId.get(source.localId) ?? [];
         const includeRoot = !previouslyPushedRoots.has(source.localId);
-        const mapped = mapSessionsToPushItems(source, sessions, { includeRoot });
+        const mapped = mapSessionsToPushItems(source, sessions, {
+            includeRoot,
+            pushedSessions: state.pushedSessions,
+        });
         nodes.push(...mapped.nodes);
         edges.push(...mapped.edges);
         if (includeRoot)
             pushedSourceRootIds.add(source.localId);
+        Object.assign(pushedSessions, mapped.pushedSessions);
     }
     if (nodes.length > 0 || edges.length > 0) {
         config = await pushSyncPayload(config, { nodes, edges });
@@ -28,6 +33,7 @@ export async function runSyncOnce() {
     await writeState({
         ...scan.nextState,
         pushedSourceRootIds: [...pushedSourceRootIds].sort(),
+        pushedSessions,
         lastSyncAt: new Date().toISOString(),
     });
     return { nodes: nodes.length, edges: edges.length };

package/dist/sync/map.js

@@ -1,28 +1,42 @@
 import { redactSecrets } from "../redact/secrets.js";
 import { contentHash, stableUuidFromString } from "./ids.js";
 export function mapSessionsToPushItems(source, sessions, options = { includeRoot: true }) {
+    const pushedSessions = options.pushedSessions ?? {};
+    const nextPushedSessions = {};
     const nodes = options.includeRoot ? [mapRootNode(source)] : [];
     const edges = [];
     for (const session of sessions) {
         const conversationId = stableUuidFromString(`${source.localId}:session:${session.id}`);
-        nodes.push({
-            node: {
-                id: conversationId,
-                integrationId: source.localId,
-                sourceId: session.sourceId,
-                name: redactSecrets(session.title),
-                kind: session.sourceKind === "codex" ? "codex_chat" : "claude_code_chat",
-                originalCreatedAt: session.createdAt,
-                originalUpdatedAt: session.updatedAt,
-            },
-            baseCloudUpdatedAt: null,
-            slices: [],
-            aiChatMessage: null,
-            nessieChatMessage: null,
-        });
-        edges.push(mapEdge(source.localId, conversationId, "source_of", 0));
+        const stateKey = sessionStateKey(source, session);
+        const sessionCursor = pushedSessions[stateKey] ?? {
+            conversationPushed: false,
+            pushedMessageCount: 0,
+        };
+        if (!sessionCursor.conversationPushed) {
+            nodes.push({
+                node: {
+                    id: conversationId,
+                    integrationId: source.localId,
+                    sourceId: session.sourceId,
+                    name: redactSecrets(session.title),
+                    kind: session.sourceKind === "codex" ? "codex_chat" : "claude_code_chat",
+                    originalCreatedAt: session.createdAt,
+                    originalUpdatedAt: session.updatedAt,
+                },
+                baseCloudUpdatedAt: null,
+                slices: [],
+                aiChatMessage: null,
+                nessieChatMessage: null,
+            });
+            edges.push(mapEdge(source.localId, conversationId, "source_of", 0));
+        }
         const pushableMessages = session.messages.filter((message) => message.role !== "system");
-        pushableMessages.forEach((message, index) => {
+        nextPushedSessions[stateKey] = {
+            conversationPushed: true,
+            pushedMessageCount: pushableMessages.length,
+        };
+        pushableMessages.slice(sessionCursor.pushedMessageCount).forEach((message, offset) => {
+            const index = sessionCursor.pushedMessageCount + offset;
             const messageId = stableUuidFromString(`${conversationId}:message:${index}`);
             const content = redactSecrets(message.content);
             const timestamp = message.timestamp ?? session.updatedAt;
@@ -54,7 +68,10 @@ export function mapSessionsToPushItems(source, sessions, options = { includeRoot
             edges.push(mapEdge(conversationId, messageId, "contains", index));
         });
     }
-    return { nodes, edges };
+    return { nodes, edges, pushedSessions: nextPushedSessions };
+}
+export function sessionStateKey(source, session) {
+    return `${source.localId}:session:${session.id}`;
 }
 function mapRootNode(source) {
     const now = new Date().toISOString();
@@ -75,9 +92,10 @@ function mapRootNode(source) {
     };
 }
 function mapEdge(fromNodeId, toNodeId, type, sortIndex) {
+    const id = stableUuidFromString(`${fromNodeId}:${type}:${toNodeId}`);
     return {
         edge: {
-            id: stableUuidFromString(`${fromNodeId}:${type}:${toNodeId}`),
+            id,
             fromNodeId,
             toNodeId,
             type,

package/dist/sync/scan.js

@@ -6,6 +6,7 @@ export async function scanSelectedSources(sources, state) {
     const nextState = {
         files: { ...state.files },
         pushedSourceRootIds: [...state.pushedSourceRootIds],
+        pushedSessions: { ...state.pushedSessions },
         lastSyncAt: state.lastSyncAt,
     };
     const sessionsBySourceId = new Map();

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@nessielabs/daemon",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Headless Linux ingestion daemon for Nessie agent traces.",
   "license": "UNLICENSED",
   "type": "module",
   "bin": {
-    "nessie-daemon": "./dist/cli.js"
+    "nessie-daemon": "dist/cli.js"
   },
   "files": [
     "dist/**/*.js",
@@ -18,7 +18,7 @@
     "node": ">=20"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "build": "rm -rf dist && tsc -p tsconfig.json && chmod +x dist/cli.js",
     "check": "tsc -p tsconfig.json --noEmit",
     "dev": "tsx src/cli.ts",
     "test": "vitest run"