@nessielabs/daemon 0.4.0 → 0.5.27

package/dist/sync/client.js

@@ -1,90 +0,0 @@
-import { ApiError, getJson, 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 = {}) {
-    const result = await postJsonWithRefresh(config, "/sync/v3/preflight", preflightBody(config), options);
-    return result.config;
-}
-export async function runPreflightV4(config, options = {}) {
-    const result = await postJsonWithRefresh(config, "/sync/v4/preflight", preflightBody(config), options);
-    return result.config;
-}
-export async function listSyncExclusions(config, options = {}) {
-    return getJsonWithRefresh(config, "/sync/v4/sync-exclusions", { kind: options.kind }, options);
-}
-export async function pullCloudSyncPage(config, input, options = {}) {
-    return postJsonWithRefresh(config, "/sync/pull/v5", {
-        deviceId: config.deviceId,
-        nodeCursor: input.nodeCursor,
-        edgeCursor: input.edgeCursor,
-        limit: input.limit,
-    }, options);
-}
-function preflightBody(config) {
-    return {
-        device: {
-            id: config.deviceId,
-            displayName: config.deviceName,
-        },
-        resources: config.selectedSources.map((source) => ({
-            kind: source.kind,
-            localId: source.localId,
-            stableKey: source.stableKey,
-            displayName: source.displayName,
-        })),
-    };
-}
-export async function pushSyncPayload(config, payload, options = {}) {
-    const result = await postJsonWithRefresh(config, "/sync/v2/push", {
-        deviceId: config.deviceId,
-        ...payload,
-    }, options);
-    return {
-        config: result.config,
-        response: {
-            nodes: Array.isArray(result.response.nodes) ? result.response.nodes : [],
-            edges: Array.isArray(result.response.edges) ? result.response.edges : [],
-        },
-    };
-}
-async function postJsonWithRefresh(config, path, body, options) {
-    const token = authToken(config);
-    try {
-        const response = await postJson(syncApiUrl, path, body, { token, fetchImpl: options.fetchImpl });
-        return { config, response };
-    }
-    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);
-    const response = await postJson(syncApiUrl, path, body, { token: authToken(refreshed), fetchImpl: options.fetchImpl });
-    return { config: refreshed, response };
-}
-async function getJsonWithRefresh(config, path, query, options) {
-    const token = authToken(config);
-    try {
-        const response = await getJson(syncApiUrl, path, { token, fetchImpl: options.fetchImpl, query });
-        return { config, response };
-    }
-    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);
-    const response = await getJson(syncApiUrl, path, { token: authToken(refreshed), fetchImpl: options.fetchImpl, query });
-    return { config: refreshed, response };
-}
-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/exclusions.js

@@ -1,10 +0,0 @@
-export function transcriptKindForSourceKind(kind) {
-    return kind === "codex" ? "codex_chat" : "claude_code_chat";
-}
-export function filterExcludedConversations(conversations, exclusions) {
-    const excludedIdentities = new Set(exclusions.map((exclusion) => identityKey(exclusion.kind, exclusion.sourceId)));
-    return conversations.filter((conversation) => !excludedIdentities.has(identityKey(transcriptKindForSourceKind(conversation.sourceKind), conversation.sourceId)));
-}
-function identityKey(kind, sourceId) {
-    return `${kind}\0${sourceId}`;
-}

package/dist/sync/hash.js

@@ -1,4 +0,0 @@
-import { createHash } from "node:crypto";
-export function contentHash(content) {
-    return createHash("sha256").update(content).digest("hex");
-}

package/dist/sync/loop.js

@@ -1,106 +0,0 @@
-import { setTimeout as sleep } from "node:timers/promises";
-import { AuthRefreshError } from "../auth/tokens.js";
-import { getDaemonPaths } from "../config/paths.js";
-import { readConfig } from "../config/store.js";
-import { GitRepoResolver } from "../git/repoResolver.js";
-import { openDaemonGraphStore } from "../localStore/daemonGraphStore.js";
-import { parserVersionForSourceKind } from "../parser/types.js";
-import { EDGE_PUSH_LIMIT, TARGET_SLICES_PER_PUSH } from "./batch.js";
-import { listSyncExclusions, pullCloudSyncPage, pushSyncPayload, runPreflightV4 } from "./client.js";
-import { filterExcludedConversations } from "./exclusions.js";
-import { fetchConversation, listSelectedSourceConversations } from "./scan.js";
-const PULL_PAGE_LIMIT = 500;
-const PULL_NODE_CURSOR_KEY = "daemonPullV4NodeCursor";
-const PULL_EDGE_CURSOR_KEY = "daemonPullV4EdgeCursor";
-export async function runSyncOnce() {
-    let config = await readConfig();
-    config = await runPreflightV4(config);
-    const exclusionsResult = await listSyncExclusions(config);
-    config = exclusionsResult.config;
-    const exclusions = exclusionsResult.response.exclusions;
-    const repoResolver = new GitRepoResolver();
-    const store = openDaemonGraphStore(getDaemonPaths().databaseFile);
-    try {
-        let nodeCursor = store.getSyncCursor(PULL_NODE_CURSOR_KEY);
-        let edgeCursor = store.getSyncCursor(PULL_EDGE_CURSOR_KEY);
-        while (true) {
-            const result = await pullCloudSyncPage(config, {
-                nodeCursor,
-                edgeCursor,
-                limit: PULL_PAGE_LIMIT,
-            });
-            config = result.config;
-            const pullResult = store.applyCloudPull(result.response);
-            if (pullResult.skippedEdges > 0) {
-                console.warn(`Skipped ${pullResult.skippedEdges} pulled edge(s) with missing endpoint nodes.`);
-            }
-            if (result.response.nextNodeCursor) {
-                nodeCursor = result.response.nextNodeCursor;
-                store.setSyncCursor(PULL_NODE_CURSOR_KEY, nodeCursor);
-            }
-            if (result.response.nextEdgeCursor) {
-                edgeCursor = result.response.nextEdgeCursor;
-                store.setSyncCursor(PULL_EDGE_CURSOR_KEY, edgeCursor);
-            }
-            if (!result.response.hasMoreNodes && !result.response.hasMoreEdges)
-                break;
-        }
-        const listings = await listSelectedSourceConversations(config.selectedSources);
-        for (const { source, conversations } of listings) {
-            const parserVersion = parserVersionForSourceKind(source.kind);
-            const filteredConversations = filterExcludedConversations(conversations, exclusions);
-            const conversationsToFetch = store.conversationsNeedingFetch(source, filteredConversations, parserVersion);
-            for (const conversation of conversationsToFetch) {
-                const session = await fetchConversation(source, conversation);
-                if (session) {
-                    store.persistSourceSessions(source, [session], {
-                        parserVersion,
-                        resolveRepo: (workspacePath) => repoResolver.resolve(workspacePath),
-                    });
-                }
-            }
-        }
-        let pushedNodes = 0;
-        let pushedEdges = 0;
-        let batchIndex = 0;
-        while (true) {
-            const batch = store.nextPushBatch({
-                targetSliceCount: TARGET_SLICES_PER_PUSH,
-                edgeLimit: EDGE_PUSH_LIMIT,
-            });
-            if (!batch)
-                break;
-            batchIndex += 1;
-            // 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 ${batchIndex}: ${batch.nodes.length} nodes, ${batch.edges.length} edges.`);
-            const result = await pushSyncPayload(config, { nodes: batch.nodes, edges: batch.edges });
-            config = result.config;
-            store.applyPushAcknowledgements(batch, result.response);
-            pushedNodes += batch.nodes.length;
-            pushedEdges += batch.edges.length;
-        }
-        store.setAppSetting("daemonLastSyncAt", new Date().toISOString());
-        for (const source of config.selectedSources) {
-            store.setAppSetting(`daemonParserVersion.${source.kind}`, String(parserVersionForSourceKind(source.kind)));
-        }
-        return { nodes: pushedNodes, edges: pushedEdges };
-    }
-    finally {
-        store.close();
-    }
-}
-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/scan.js

@@ -1,245 +0,0 @@
-import { createReadStream } from "node:fs";
-import { open, readdir, readFile, stat } from "node:fs/promises";
-import { basename, join, relative } from "node:path";
-import { createInterface } from "node:readline";
-import { asRecord, stringValue } from "../parser/jsonl.js";
-import { parseClaudeCodeSession } from "../parser/claudeCode.js";
-import { parseCodexSession } from "../parser/codex.js";
-const CODEX_ROOTS = [
-    { directoryName: "sessions", priority: 0 },
-    { directoryName: "archived_sessions", priority: 1 },
-];
-export async function listSelectedSourceConversations(sources) {
-    return Promise.all(sources.map(async (source) => ({
-        source,
-        conversations: source.kind === "codex"
-            ? await listCodexConversations(source)
-            : await listClaudeCodeConversations(source),
-    })));
-}
-export async function fetchConversation(source, conversation) {
-    const parsed = source.kind === "codex"
-        ? await parseCodexSession(conversation.path)
-        : await parseClaudeCodeSession(conversation.path);
-    if (!parsed)
-        return null;
-    return {
-        ...parsed,
-        sourceId: conversation.sourceId,
-        updatedAt: conversation.lastMessageTime ?? conversation.updatedAt ?? parsed.updatedAt,
-        cwd: conversation.cwd ?? parsed.cwd,
-    };
-}
-async function listCodexConversations(source) {
-    const importedThreadIds = await externalImportedThreadIds(source.basePath);
-    const refs = [];
-    for (const root of CODEX_ROOTS) {
-        const rootPath = join(source.basePath, root.directoryName);
-        const files = await walkJsonl(rootPath);
-        for (const path of files) {
-            const summary = await summarizeCodexSession(path);
-            if (!summary.isConversation)
-                continue;
-            const relativePath = relative(rootPath, path);
-            const fallbackSessionId = basename(relativePath, ".jsonl");
-            const sessionId = summary.sessionId ?? fallbackSessionId;
-            if (importedThreadIds.has(sessionId))
-                continue;
-            const attrs = await stat(path);
-            refs.push({
-                sourceLocalId: source.localId,
-                sourceKind: "codex",
-                sourceId: sessionId,
-                path,
-                updatedAt: attrs.mtime.toISOString(),
-                lastMessageTime: await peekLastMessageTime(path, isCodexMessageRecord),
-                cwd: summary.cwd,
-                rootPriority: root.priority,
-            });
-        }
-    }
-    return deduplicateCodexRefs(refs).sort((left, right) => recencyMillis(right) - recencyMillis(left));
-}
-async function listClaudeCodeConversations(source) {
-    const projectsPath = join(source.basePath, "projects");
-    let projectDirs;
-    try {
-        projectDirs = await readdir(projectsPath, { withFileTypes: true });
-    }
-    catch (error) {
-        if (isNotFound(error))
-            return [];
-        throw error;
-    }
-    const refs = [];
-    for (const projectDir of projectDirs.filter((entry) => entry.isDirectory()).sort((a, b) => a.name.localeCompare(b.name))) {
-        const projectPath = join(projectsPath, projectDir.name);
-        let entries;
-        try {
-            entries = await readdir(projectPath, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        for (const entry of entries.filter((item) => item.isFile() && item.name.endsWith(".jsonl"))) {
-            const path = join(projectPath, entry.name);
-            const attrs = await stat(path);
-            refs.push({
-                sourceLocalId: source.localId,
-                sourceKind: "claude_code",
-                sourceId: basename(entry.name, ".jsonl"),
-                path,
-                updatedAt: attrs.mtime.toISOString(),
-                lastMessageTime: await peekLastMessageTime(path, isClaudeCodeMessageRecord),
-            });
-        }
-    }
-    return refs.sort((left, right) => recencyMillis(right) - recencyMillis(left));
-}
-async function summarizeCodexSession(path) {
-    let sessionId = null;
-    let cwd = null;
-    let hasUser = false;
-    let hasAssistant = false;
-    const stream = createReadStream(path, { encoding: "utf8" });
-    const lines = createInterface({ input: stream, crlfDelay: Infinity });
-    try {
-        for await (const line of lines) {
-            const record = parseJsonRecord(line);
-            if (!record)
-                continue;
-            if (stringValue(record.type) === "session_meta") {
-                const payload = asRecord(record.payload);
-                sessionId ??= stringValue(payload?.id) ?? stringValue(record.id) ?? stringValue(record.session_id);
-                cwd ??= stringValue(payload?.cwd) ?? stringValue(record.cwd);
-                continue;
-            }
-            if (!isCodexMessageRecord(record))
-                continue;
-            const role = codexRecordRole(record);
-            hasUser ||= role === "user";
-            hasAssistant ||= role === "assistant";
-            if (hasUser && hasAssistant) {
-                lines.close();
-                stream.destroy();
-                break;
-            }
-        }
-    }
-    catch {
-        return { sessionId, cwd, isConversation: false };
-    }
-    return { sessionId, cwd, isConversation: hasUser && hasAssistant };
-}
-async function externalImportedThreadIds(basePath) {
-    try {
-        const content = await readFile(join(basePath, "external_agent_session_imports.json"), "utf8");
-        const parsed = JSON.parse(content);
-        const records = asRecord(parsed)?.records;
-        if (!Array.isArray(records))
-            return new Set();
-        return new Set(records.flatMap((record) => {
-            const id = stringValue(asRecord(record)?.imported_thread_id);
-            return id ? [id] : [];
-        }));
-    }
-    catch {
-        return new Set();
-    }
-}
-async function peekLastMessageTime(path, isMessageRecord) {
-    let file;
-    try {
-        file = await open(path, "r");
-        const { size } = await file.stat();
-        const readSize = Math.min(size, 50_000);
-        const buffer = Buffer.alloc(readSize);
-        await file.read(buffer, 0, readSize, size - readSize);
-        const tail = buffer.toString("utf8");
-        for (const line of tail.split(/\r?\n/).reverse()) {
-            const record = parseJsonRecord(line);
-            if (!record || !isMessageRecord(record))
-                continue;
-            const timestamp = stringValue(record.timestamp) ?? stringValue(record.created_at);
-            if (timestamp)
-                return timestamp;
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-    finally {
-        await file?.close();
-    }
-}
-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 (isNotFound(error))
-            return [];
-        throw error;
-    }
-}
-function deduplicateCodexRefs(refs) {
-    const selected = new Map();
-    for (const ref of refs) {
-        const existing = selected.get(ref.sourceId);
-        if (!existing || shouldPreferCodexRef(ref, existing))
-            selected.set(ref.sourceId, ref);
-    }
-    return [...selected.values()].map(({ rootPriority: _rootPriority, ...ref }) => ref);
-}
-function shouldPreferCodexRef(candidate, existing) {
-    if (candidate.rootPriority !== existing.rootPriority)
-        return candidate.rootPriority < existing.rootPriority;
-    return recencyMillis(candidate) > recencyMillis(existing);
-}
-function recencyMillis(ref) {
-    return Date.parse(ref.lastMessageTime ?? ref.updatedAt ?? "") || 0;
-}
-function parseJsonRecord(line) {
-    if (!line.trim())
-        return null;
-    try {
-        return asRecord(JSON.parse(line));
-    }
-    catch {
-        return null;
-    }
-}
-function isCodexMessageRecord(record) {
-    return codexRecordRole(record) !== null;
-}
-function codexRecordRole(record) {
-    if (stringValue(record.type) !== "event_msg")
-        return null;
-    const payload = asRecord(record.payload) ?? record;
-    const role = stringValue(payload.role);
-    if (role === "user" || role === "assistant")
-        return role;
-    const messageType = stringValue(payload.type) ?? stringValue(payload.kind);
-    if (messageType?.includes("user"))
-        return "user";
-    if (messageType === "task_complete")
-        return "assistant";
-    if (messageType?.includes("agent") || messageType?.includes("assistant"))
-        return "assistant";
-    return null;
-}
-function isClaudeCodeMessageRecord(record) {
-    const role = stringValue(asRecord(record.message)?.role);
-    return role === "user" || role === "assistant";
-}
-function isNotFound(error) {
-    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}

package/dist/sync/slices.js

@@ -1,63 +0,0 @@
-import { contentHash } from "./hash.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;
-}
-export function contentHashesFor(content) {
-    return splitContent(content).map((piece) => contentHash(piece));
-}

package/dist/sync/types.js

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