@nessielabs/daemon 0.3.2 → 0.5.26

package/dist/service/systemd.js

@@ -1,38 +0,0 @@
-import { execFile } from "node:child_process";
-import { mkdir, writeFile } from "node:fs/promises";
-import { promisify } from "node:util";
-import { getDaemonPaths } from "../config/paths.js";
-const execFileAsync = promisify(execFile);
-export async function installUserService(paths = getDaemonPaths()) {
-    await mkdir(paths.systemdUserDir, { recursive: true });
-    const service = buildUserServiceFile(process.execPath, process.argv[1] ?? "nessie-daemon");
-    await writeFile(paths.systemdServiceFile, service);
-    await systemctl("daemon-reload");
-    await systemctl("enable", "nessie-daemon.service");
-    await systemctl("start", "nessie-daemon.service");
-}
-export function buildUserServiceFile(nodePath, cliPath) {
-    return [
-        "[Unit]",
-        "Description=Nessie daemon",
-        "Wants=network-online.target",
-        "After=network-online.target",
-        "",
-        "[Service]",
-        "Type=simple",
-        `ExecStart=${systemdQuote(nodePath)} ${systemdQuote(cliPath)} run`,
-        "Restart=always",
-        "RestartSec=30",
-        "",
-        "[Install]",
-        "WantedBy=default.target",
-        "",
-    ].join("\n");
-}
-export async function systemctl(...args) {
-    const { stdout, stderr } = await execFileAsync("systemctl", ["--user", ...args]);
-    return stdout || stderr;
-}
-function systemdQuote(value) {
-    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
-}

package/dist/sources/detect.js

@@ -1,43 +0,0 @@
-import { access } from "node:fs/promises";
-import { homedir, hostname } from "node:os";
-import { join } from "node:path";
-export async function detectSources() {
-    return detectSourcesInHome(homedir(), hostname());
-}
-export async function detectSourcesInHome(home, host) {
-    const candidates = [
-        {
-            kind: "claude_code",
-            displayName: `Claude Code on ${host}`,
-            basePath: join(home, ".claude"),
-        },
-        {
-            kind: "codex",
-            displayName: `Codex on ${host}`,
-            basePath: join(home, ".codex"),
-        },
-    ];
-    const detected = [];
-    for (const candidate of candidates) {
-        if (await exists(sourceProbePath(candidate)))
-            detected.push(candidate);
-    }
-    return detected;
-}
-function sourceProbePath(source) {
-    switch (source.kind) {
-        case "claude_code":
-            return join(source.basePath, "projects");
-        case "codex":
-            return join(source.basePath, "sessions");
-    }
-}
-async function exists(path) {
-    try {
-        await access(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}

package/dist/sync/batch.js

@@ -1,50 +0,0 @@
-/**
- * Target number of content slices per node push request.
- *
- * Mirrors `CloudSyncPipeline.targetSlicesPerPush` in the macOS app. Batching by
- * slice count keeps each request well under Cloud Run's 32 MiB body limit, which
- * a single all-in-one push of a large cold sync would blow past (413).
- */
-export const TARGET_SLICES_PER_PUSH = 200;
-/**
- * Maximum edges per push request. Mirrors the macOS app's `edgeLimit`. Edges
- * carry only ids, so this bound is about request count, not size.
- */
-export const EDGE_PUSH_LIMIT = 500;
-/**
- * Split a push into request-sized batches, mirroring the macOS client.
- *
- * All node batches are emitted before any edge batch: edges carry foreign keys
- * to their endpoint nodes, so every node pushed in this sync must land before
- * the edges that reference it. Within a sync, node ordering is otherwise
- * irrelevant — `node.integration_id` is not a foreign key — so nodes are batched
- * purely by accumulated slice count.
- *
- * A node whose own slice count exceeds `targetSliceCount` is still emitted as
- * its own batch rather than dropped, matching the macOS app's "a single large
- * node is kept intact" behaviour.
- */
-export function planSyncPushBatches(nodes, edges, options = {}) {
-    const targetSliceCount = options.targetSliceCount ?? TARGET_SLICES_PER_PUSH;
-    const edgeLimit = options.edgeLimit ?? EDGE_PUSH_LIMIT;
-    const batches = [];
-    let currentNodes = [];
-    let sliceCount = 0;
-    for (const node of nodes) {
-        const nodeSliceCount = node.slices.length;
-        if (currentNodes.length > 0 && sliceCount + nodeSliceCount > targetSliceCount) {
-            batches.push({ nodes: currentNodes, edges: [] });
-            currentNodes = [];
-            sliceCount = 0;
-        }
-        currentNodes.push(node);
-        sliceCount += nodeSliceCount;
-    }
-    if (currentNodes.length > 0) {
-        batches.push({ nodes: currentNodes, edges: [] });
-    }
-    for (let offset = 0; offset < edges.length; offset += edgeLimit) {
-        batches.push({ nodes: [], edges: edges.slice(offset, offset + edgeLimit) });
-    }
-    return batches;
-}

package/dist/sync/client.js

@@ -1,47 +0,0 @@
-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", {
-        device: {
-            id: config.deviceId,
-            displayName: config.deviceName,
-        },
-        resources: config.selectedSources.map((source) => ({
-            kind: source.kind,
-            localId: source.localId,
-            stableKey: source.stableKey,
-            displayName: source.displayName,
-        })),
-    }, options);
-}
-export async function pushSyncPayload(config, payload, options = {}) {
-    return postJsonWithRefresh(config, "/sync/v2/push", {
-        deviceId: config.deviceId,
-        ...payload,
-    }, options);
-}
-async function postJsonWithRefresh(config, path, body, options) {
-    const token = authToken(config);
-    try {
-        await postJson(syncApiUrl, 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(syncApiUrl, 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/dist/sync/ids.js

@@ -1,11 +0,0 @@
-import { createHash } from "node:crypto";
-export function stableUuidFromString(input) {
-    const bytes = createHash("sha256").update(input).digest().subarray(0, 16);
-    bytes[6] = (bytes[6] & 0x0f) | 0x80;
-    bytes[8] = (bytes[8] & 0x3f) | 0x80;
-    const hex = bytes.toString("hex");
-    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
-export function contentHash(content) {
-    return createHash("sha256").update(content).digest("hex");
-}

package/dist/sync/loop.js

@@ -1,76 +0,0 @@
-import { setTimeout as sleep } from "node:timers/promises";
-import { AuthRefreshError } from "../auth/tokens.js";
-import { readConfig, readState, writeState } from "../config/store.js";
-import { GitRepoResolver } from "../git/repoResolver.js";
-import { PARSER_VERSION } from "../parser/types.js";
-import { planSyncPushBatches } from "./batch.js";
-import { runPreflightV3, pushSyncPayload } from "./client.js";
-import { mapSessionsToPushItems } from "./map.js";
-import { scanSelectedSources } from "./scan.js";
-export async function runSyncOnce() {
-    let config = await readConfig();
-    const state = await readState();
-    config = await runPreflightV3(config);
-    // A parser version bump reparses everything once and re-pushes conversation
-    // headers as field-masked merges so existing conversations pick up newly
-    // extracted metadata. The state only records the new version after a
-    // successful push, so a failed backfill retries on the next run.
-    const backfillParserChanges = state.parserVersion < PARSER_VERSION;
-    const scan = await scanSelectedSources(config.selectedSources, state, {
-        forceReparse: backfillParserChanges,
-    });
-    const repoResolver = new GitRepoResolver();
-    const nodes = [];
-    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,
-            pushedSessions: state.pushedSessions,
-            repushHeaders: backfillParserChanges,
-            resolveRepo: (workspacePath) => repoResolver.resolve(workspacePath),
-        });
-        nodes.push(...mapped.nodes);
-        edges.push(...mapped.edges);
-        if (includeRoot)
-            pushedSourceRootIds.add(source.localId);
-        Object.assign(pushedSessions, mapped.pushedSessions);
-    }
-    // Push in request-sized batches (all nodes before any edges) so a large cold
-    // sync stays under Cloud Run's body limit. Each batch push is idempotent, and
-    // sync state is only written after every batch succeeds, so a mid-stream
-    // failure simply re-pushes the whole set on the next run.
-    const batches = planSyncPushBatches(nodes, edges);
-    for (const [index, batch] of batches.entries()) {
-        // Per-batch logging keeps a long cold sync diagnosable when it would
-        // otherwise be silent across hundreds of sequential requests.
-        console.log(`Pushing sync batch ${index + 1}/${batches.length}: ${batch.nodes.length} nodes, ${batch.edges.length} edges.`);
-        config = await pushSyncPayload(config, batch);
-    }
-    await writeState({
-        ...scan.nextState,
-        pushedSourceRootIds: [...pushedSourceRootIds].sort(),
-        pushedSessions,
-        parserVersion: PARSER_VERSION,
-        lastSyncAt: new Date().toISOString(),
-    });
-    return { nodes: nodes.length, edges: edges.length };
-}
-export async function runSyncLoop(intervalSeconds) {
-    while (true) {
-        try {
-            const result = await runSyncOnce();
-            console.log(`Synced ${result.nodes} nodes and ${result.edges} edges.`);
-        }
-        catch (error) {
-            console.error(error instanceof Error ? error.message : String(error));
-            if (error instanceof AuthRefreshError)
-                throw error;
-        }
-        await sleep(Math.max(5, intervalSeconds) * 1000);
-    }
-}

package/dist/sync/map.js

@@ -1,111 +0,0 @@
-import { redactSecrets } from "../redact/secrets.js";
-import { stableUuidFromString } from "./ids.js";
-import { buildContentSlices, takeGraphemes } from "./slices.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}`);
-        const stateKey = sessionStateKey(source, session);
-        const sessionCursor = pushedSessions[stateKey] ?? {
-            conversationPushed: false,
-            pushedMessageCount: 0,
-        };
-        if (!sessionCursor.conversationPushed || options.repushHeaders === true) {
-            const repoInfo = session.cwd !== null ? options.resolveRepo?.(session.cwd) ?? null : null;
-            // Headers always push as a field-masked merge: new conversations insert
-            // normally, and re-pushed headers only touch the workspace metadata
-            // columns, never fields other clients own (name, labels, deletion).
-            nodes.push({
-                node: {
-                    id: conversationId,
-                    integrationId: source.localId,
-                    sourceId: session.sourceId,
-                    name: redactSecrets(session.title),
-                    kind: session.sourceKind === "codex" ? "codex_chat" : "claude_code_chat",
-                    workspacePath: session.cwd,
-                    repoRemoteUrl: repoInfo?.remoteUrl ?? null,
-                    repoKey: repoInfo?.repoKey ?? null,
-                    originalCreatedAt: session.createdAt,
-                    originalUpdatedAt: session.updatedAt,
-                },
-                baseCloudUpdatedAt: null,
-                slices: [],
-                aiChatMessage: null,
-                nessieChatMessage: null,
-                mergeFields: ["workspacePath", "repoRemoteUrl", "repoKey"],
-            });
-        }
-        if (!sessionCursor.conversationPushed) {
-            edges.push(mapEdge(source.localId, conversationId, "source_of", 0));
-        }
-        const pushableMessages = session.messages.filter((message) => message.role !== "system");
-        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;
-            nodes.push({
-                node: {
-                    id: messageId,
-                    integrationId: source.localId,
-                    sourceId: `${session.sourceId}#${index}`,
-                    name: takeGraphemes(content, 80) || message.role,
-                    kind: session.sourceKind === "codex" ? "codex_chat_message" : "claude_code_chat_message",
-                    originalCreatedAt: timestamp,
-                    originalUpdatedAt: timestamp,
-                },
-                baseCloudUpdatedAt: null,
-                slices: buildContentSlices(messageId, content),
-                aiChatMessage: {
-                    nodeId: messageId,
-                    role: message.role,
-                    author: null,
-                },
-                nessieChatMessage: null,
-            });
-            edges.push(mapEdge(conversationId, messageId, "contains", index));
-        });
-    }
-    return { nodes, edges, pushedSessions: nextPushedSessions };
-}
-export function sessionStateKey(source, session) {
-    return `${source.localId}:session:${session.id}`;
-}
-function mapRootNode(source) {
-    const now = new Date().toISOString();
-    return {
-        node: {
-            id: source.localId,
-            integrationId: source.localId,
-            sourceId: source.basePath,
-            name: redactSecrets(source.displayName),
-            kind: "integration_root",
-            originalCreatedAt: now,
-            originalUpdatedAt: now,
-        },
-        baseCloudUpdatedAt: null,
-        slices: [],
-        aiChatMessage: null,
-        nessieChatMessage: null,
-    };
-}
-function mapEdge(fromNodeId, toNodeId, type, sortIndex) {
-    const id = stableUuidFromString(`${fromNodeId}:${type}:${toNodeId}`);
-    return {
-        edge: {
-            id,
-            fromNodeId,
-            toNodeId,
-            type,
-            sortIndex,
-        },
-        baseCloudUpdatedAt: null,
-    };
-}

package/dist/sync/scan.js

@@ -1,60 +0,0 @@
-import { readdir, stat } from "node:fs/promises";
-import { join } from "node:path";
-import { parseClaudeCodeSession } from "../parser/claudeCode.js";
-import { parseCodexSession } from "../parser/codex.js";
-export async function scanSelectedSources(sources, state, options = {}) {
-    const nextState = {
-        files: { ...state.files },
-        pushedSourceRootIds: [...state.pushedSourceRootIds],
-        pushedSessions: { ...state.pushedSessions },
-        parserVersion: state.parserVersion,
-        lastSyncAt: state.lastSyncAt,
-    };
-    const sessionsBySourceId = new Map();
-    for (const source of sources) {
-        const files = await sessionFilesForSource(source);
-        const sessions = [];
-        for (const file of files) {
-            const cursor = await cursorForFile(file);
-            if (options.forceReparse !== true && isUnchanged(state.files[file], cursor))
-                continue;
-            const session = source.kind === "codex" ? await parseCodexSession(file) : await parseClaudeCodeSession(file);
-            nextState.files[file] = cursor;
-            if (session)
-                sessions.push(session);
-        }
-        sessionsBySourceId.set(source.localId, sessions);
-    }
-    return { sessionsBySourceId, nextState };
-}
-async function sessionFilesForSource(source) {
-    const root = source.kind === "codex" ? join(source.basePath, "sessions") : join(source.basePath, "projects");
-    return walkJsonl(root);
-}
-async function walkJsonl(root) {
-    try {
-        const entries = await readdir(root, { withFileTypes: true });
-        const nested = await Promise.all(entries.map(async (entry) => {
-            const path = join(root, entry.name);
-            if (entry.isDirectory())
-                return walkJsonl(path);
-            return entry.isFile() && entry.name.endsWith(".jsonl") ? [path] : [];
-        }));
-        return nested.flat().sort();
-    }
-    catch (error) {
-        if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT")
-            return [];
-        throw error;
-    }
-}
-async function cursorForFile(file) {
-    const stats = await stat(file);
-    return {
-        mtimeMs: stats.mtimeMs,
-        size: stats.size,
-    };
-}
-function isUnchanged(previous, next) {
-    return previous?.mtimeMs === next.mtimeMs && previous.size === next.size;
-}

package/dist/sync/slices.js

@@ -1,74 +0,0 @@
-import { contentHash, stableUuidFromString } from "./ids.js";
-/**
- * Default maximum character count for a content slice.
- *
- * Mirrors `NodeContentSlice.defaultContentSliceSize` in NessieCore so the
- * daemon produces the same slice granularity as the macOS client.
- */
-export const DEFAULT_CONTENT_SLICE_SIZE = 800;
-// Swift's `String.index(_:offsetBy:)` advances by `Character`, i.e. extended
-// grapheme clusters, so its 800-unit slices never split a grapheme. Segmenting
-// by grapheme here matches that behaviour rather than slicing by UTF-16 code
-// units, which would cut emoji and combining sequences in half. A fixed locale
-// keeps grapheme boundaries deterministic across daemon hosts regardless of the
-// process locale (e.g. LANG=C).
-const graphemeSegmenter = new Intl.Segmenter("en-US", { granularity: "grapheme" });
-/**
- * Split content into the canonical chunks used for node content slices.
- *
- * Ports `NodeContentSlice.splitContent` from NessieCore: empty content yields a
- * single empty slice, and non-empty content is chunked into `sliceSize`
- * grapheme runs.
- */
-export function splitContent(content, sliceSize = DEFAULT_CONTENT_SLICE_SIZE) {
-    if (content === "")
-        return [""];
-    const pieces = [];
-    let current = "";
-    let count = 0;
-    for (const { segment } of graphemeSegmenter.segment(content)) {
-        current += segment;
-        count += 1;
-        if (count === sliceSize) {
-            pieces.push(current);
-            current = "";
-            count = 0;
-        }
-    }
-    if (count > 0)
-        pieces.push(current);
-    return pieces;
-}
-/**
- * Take the first `count` grapheme clusters of `content`.
- *
- * Used for short display names so a truncation boundary never severs an emoji
- * or combining sequence the way a UTF-16 `content.slice(0, count)` would.
- */
-export function takeGraphemes(content, count) {
-    if (count <= 0)
-        return "";
-    let result = "";
-    let taken = 0;
-    for (const { segment } of graphemeSegmenter.segment(content)) {
-        result += segment;
-        taken += 1;
-        if (taken === count)
-            break;
-    }
-    return result;
-}
-/**
- * Build the content slices for a message node from its already-redacted
- * content. Slice 0 keeps the same stable id the daemon used when every message
- * was a single slice, so re-pushes stay idempotent.
- */
-export function buildContentSlices(nodeId, content) {
-    return splitContent(content).map((piece, index) => ({
-        id: stableUuidFromString(`${nodeId}:slice:${index}`),
-        nodeId,
-        index,
-        content: piece,
-        contentHash: contentHash(piece),
-    }));
-}

package/dist/sync/types.js

@@ -1 +0,0 @@
-export {};