@nessielabs/daemon 0.3.1 → 0.4.0

package/dist/localStore/messageComparison.js

@@ -0,0 +1,37 @@
+import { redactSecrets } from "../redact/secrets.js";
+import { contentHashesFor } from "../sync/slices.js";
+export function messageMatches(existing, draft, kind) {
+    return existing.node.kind === kind &&
+        existing.role === draft.role &&
+        existing.author === null &&
+        existing.toolCallId === null &&
+        existing.toolName === null &&
+        existing.toolStatus === null &&
+        arrayEquals(existing.contentHashes, contentHashesFor(redactSecrets(draft.content)));
+}
+export function messageMetadataChanged(node, draft, integrationId, kind, timestamp) {
+    return node.integrationId?.equals(integrationId) !== true ||
+        node.name !== messageNodeName(draft) ||
+        node.kind !== kind ||
+        node.originalCreatedAt !== timestamp ||
+        node.originalUpdatedAt !== timestamp ||
+        node.deletedAt !== null;
+}
+export function messageTimestamp(message, session) {
+    return message.timestamp ?? session.updatedAt;
+}
+export function messageNodeName(message) {
+    switch (message.role) {
+        case "user":
+            return "User Message";
+        case "assistant":
+            return "Assistant Message";
+        case "tool":
+            return "Tool Message";
+        case "system":
+            return "System Message";
+    }
+}
+function arrayEquals(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}

package/dist/localStore/pushMapping.js

@@ -0,0 +1,69 @@
+import { uuidFromBytes } from "./uuid.js";
+export function mapNodePushItem(db, row) {
+    const id = uuidFromBytes(row.id);
+    return {
+        node: {
+            id,
+            integrationId: row.integrationId ? uuidFromBytes(row.integrationId) : null,
+            sourceId: row.sourceId,
+            name: row.name,
+            kind: row.kind,
+            emoji: row.emoji,
+            pinned: row.pinned === 1,
+            label: row.label,
+            labelSliceCount: row.labelSliceCount,
+            workspacePath: row.workspacePath,
+            repoRemoteUrl: row.repoRemoteUrl,
+            repoKey: row.repoKey,
+            deletedAt: row.deletedAt,
+            originalCreatedAt: row.originalCreatedAt,
+            originalUpdatedAt: row.originalUpdatedAt,
+        },
+        baseCloudUpdatedAt: row.cloudUpdatedAt,
+        slices: nodeSlices(db, row.id),
+        aiChatMessage: aiChatMessage(db, id, row.id),
+        nessieChatMessage: null,
+    };
+}
+export function mapEdgePushItem(row) {
+    return {
+        edge: {
+            id: uuidFromBytes(row.id),
+            fromNodeId: uuidFromBytes(row.fromNodeId),
+            toNodeId: uuidFromBytes(row.toNodeId),
+            type: row.type,
+            sortIndex: row.sortIndex,
+            deletedAt: row.deletedAt,
+        },
+        baseCloudUpdatedAt: row.cloudUpdatedAt,
+    };
+}
+function nodeSlices(db, nodeId) {
+    const rows = db.prepare(`
+    SELECT id, nodeId, "index", content, contentHash
+    FROM node_content_slice
+    WHERE nodeId = ?
+    ORDER BY "index" ASC
+  `).all(nodeId);
+    return rows.map((row) => ({
+        id: uuidFromBytes(row.id),
+        nodeId: uuidFromBytes(row.nodeId),
+        index: row.index,
+        content: row.content,
+        contentHash: row.contentHash,
+    }));
+}
+function aiChatMessage(db, id, nodeId) {
+    const row = db.prepare("SELECT * FROM ai_chat_message WHERE nodeId = ?").get(nodeId);
+    if (!row)
+        return null;
+    return {
+        nodeId: id,
+        role: row.role,
+        author: row.author,
+        toolCallId: row.toolCallId,
+        toolName: row.toolName,
+        toolFriendlyName: row.toolFriendlyName,
+        toolStatus: row.toolStatus,
+    };
+}

package/dist/localStore/rowTypes.js

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

package/dist/localStore/schema.js

@@ -0,0 +1,70 @@
+export function createDaemonGraphSchema(db) {
+    db.pragma("foreign_keys = ON");
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS node (
+      id BLOB PRIMARY KEY,
+      integrationId BLOB,
+      sourceId TEXT,
+      name TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      emoji TEXT,
+      pinned BOOLEAN NOT NULL DEFAULT 0,
+      label TEXT,
+      labelSliceCount INTEGER,
+      workspacePath TEXT,
+      repoRemoteUrl TEXT,
+      repoKey TEXT,
+      createdAt DATETIME NOT NULL,
+      updatedAt DATETIME NOT NULL,
+      lastPushedAt DATETIME,
+      cloudUpdatedAt DATETIME,
+      parserVersion INTEGER,
+      deletedAt DATETIME,
+      originalCreatedAt DATETIME NOT NULL,
+      originalUpdatedAt DATETIME NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS node_kind_source_id_idx ON node(kind, sourceId);
+
+    CREATE TABLE IF NOT EXISTS node_edge (
+      id BLOB PRIMARY KEY,
+      fromNodeId BLOB NOT NULL REFERENCES node(id) ON DELETE CASCADE,
+      toNodeId BLOB NOT NULL REFERENCES node(id) ON DELETE CASCADE,
+      type TEXT NOT NULL,
+      sortIndex INTEGER,
+      createdAt DATETIME NOT NULL,
+      updatedAt DATETIME NOT NULL,
+      lastPushedAt DATETIME,
+      cloudUpdatedAt DATETIME,
+      deletedAt DATETIME
+    );
+    CREATE INDEX IF NOT EXISTS node_edge_from_to_type_idx ON node_edge(fromNodeId, toNodeId, type);
+    CREATE INDEX IF NOT EXISTS node_edge_from_type_sort_null_to_idx
+      ON node_edge("fromNodeId", "type", "sortIndex" IS NULL, "sortIndex", "toNodeId");
+    CREATE INDEX IF NOT EXISTS node_edge_to_type_idx ON node_edge(toNodeId, type);
+
+    CREATE TABLE IF NOT EXISTS node_content_slice (
+      id BLOB PRIMARY KEY,
+      nodeId BLOB NOT NULL REFERENCES node(id) ON DELETE CASCADE,
+      "index" INTEGER NOT NULL,
+      content TEXT NOT NULL,
+      contentHash TEXT NOT NULL
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS node_content_slice_node_index_idx ON node_content_slice(nodeId, "index");
+
+    CREATE TABLE IF NOT EXISTS ai_chat_message (
+      nodeId BLOB PRIMARY KEY REFERENCES node(id) ON DELETE CASCADE,
+      role TEXT NOT NULL,
+      author TEXT,
+      toolCallId TEXT,
+      toolName TEXT,
+      toolFriendlyName TEXT,
+      toolStatus TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS app_setting (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+  `);
+}

package/dist/localStore/uuid.js

@@ -0,0 +1,12 @@
+export function uuidToBytes(uuid) {
+    const hex = uuid.replaceAll("-", "");
+    if (!/^[0-9a-fA-F]{32}$/.test(hex))
+        throw new Error(`Invalid UUID: ${uuid}`);
+    return Buffer.from(hex, "hex");
+}
+export function uuidFromBytes(bytes) {
+    const hex = bytes.toString("hex");
+    if (hex.length !== 32)
+        throw new Error(`Invalid UUID byte length: ${bytes.length}`);
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}

package/dist/parser/claudeCode.js

@@ -4,11 +4,18 @@ import { asRecord, readJsonl, stringValue } from "./jsonl.js";
 export async function parseClaudeCodeSession(path) {
     const records = await readJsonl(path);
     const messages = [];
-    let sessionId = basename(path, ".jsonl");
+    // Anchor session identity to the JSONL filename, matching the macOS client.
+    // The in-file `sessionId` is reused across files for worktree/resumed
+    // sessions, so keying on it collapses distinct transcripts into one
+    // conversation id and makes their deterministic message ids collide (409).
+    const sessionId = basename(path, ".jsonl");
     let title = null;
+    let customTitle = null;
+    let aiTitle = null;
     let createdAt = null;
     let updatedAt = null;
     let cwd = null;
+    const interactiveToolUseIds = new Set();
     for (const value of records) {
         const record = asRecord(value);
         if (!record)
@@ -17,21 +24,32 @@ export async function parseClaudeCodeSession(path) {
         // it before any filtering. The path-encoded project directory name is
         // lossy (dashes vs. path separators), so this is the only reliable source.
         cwd ??= stringValue(record.cwd);
+        const type = stringValue(record.type);
+        if (type === "custom-title") {
+            customTitle = trimmedTitle(record.customTitle) ?? customTitle;
+            continue;
+        }
+        if (type === "ai-title") {
+            aiTitle = trimmedTitle(record.aiTitle) ?? aiTitle;
+            continue;
+        }
         if (record.isSidechain === true)
             continue;
-        sessionId = stringValue(record.sessionId) ?? stringValue(record.session_id) ?? sessionId;
         const timestamp = stringValue(record.timestamp);
+        const message = asRecord(record.message);
+        const role = normalizeRole(stringValue(message?.role) ?? type ?? stringValue(record.role));
+        if (!role || !message)
+            continue;
+        const text = role === "assistant"
+            ? extractAssistantText(message, interactiveToolUseIds)
+            : extractUserText(message, interactiveToolUseIds);
+        if (!text)
+            continue;
+        messages.push({ role, content: text, timestamp });
         if (timestamp) {
             createdAt ??= timestamp;
             updatedAt = timestamp;
         }
-        const role = normalizeRole(stringValue(record.type) ?? stringValue(record.role));
-        if (!role)
-            continue;
-        const text = extractClaudeText(record);
-        if (!text || shouldDropScaffolding(text))
-            continue;
-        messages.push({ role, content: text, timestamp });
         if (!title && role === "user")
             title = redactSecrets(firstLine(text));
     }
@@ -41,8 +59,8 @@ export async function parseClaudeCodeSession(path) {
     return {
         id: sessionId,
         sourceKind: "claude_code",
-        sourceId: path,
-        title: title ?? "Claude Code conversation",
+        sourceId: sessionId,
+        title: redactSecrets(customTitle ?? aiTitle ?? title ?? "Claude Code conversation"),
         createdAt: createdAt ?? now,
         updatedAt: updatedAt ?? createdAt ?? now,
         cwd,
@@ -54,28 +72,131 @@ function normalizeRole(role) {
         return role;
     return null;
 }
-function extractClaudeText(record) {
-    const direct = stringValue(record.message);
-    if (direct)
-        return direct;
-    const message = asRecord(record.message);
-    if (!message)
-        return null;
+const interactiveToolNames = new Set([
+    "AskUserQuestion",
+    "mcp__conductor__AskUserQuestion",
+]);
+function extractAssistantText(message, interactiveToolUseIds) {
     const content = message.content;
     if (typeof content === "string")
-        return content;
+        return content.trim().length > 0 ? content : null;
     if (!Array.isArray(content))
         return null;
     const parts = content.flatMap((item) => {
         const part = asRecord(item);
-        const text = part ? stringValue(part.text) : null;
-        return text ? [text] : [];
+        if (!part)
+            return [];
+        if (stringValue(part.type) === "text") {
+            const text = stringValue(part.text);
+            return text ? [text] : [];
+        }
+        if (stringValue(part.type) === "tool_use") {
+            const toolName = stringValue(part.name);
+            const toolUseId = stringValue(part.id);
+            if (!toolName || !toolUseId || !interactiveToolNames.has(toolName))
+                return [];
+            interactiveToolUseIds.add(toolUseId);
+            const questionText = extractAskUserQuestionText(part);
+            return questionText ? [questionText] : [];
+        }
+        return [];
     });
     return parts.length > 0 ? parts.join("\n\n") : null;
 }
-function shouldDropScaffolding(text) {
-    return text.startsWith("<command-name>") || text.startsWith("<local-command-stdout>");
+function extractUserText(message, interactiveToolUseIds) {
+    const content = message.content;
+    if (typeof content === "string") {
+        if (isSkillDefinition(content))
+            return null;
+        const cleaned = stripScaffolding(content);
+        return cleaned.length > 0 ? cleaned : null;
+    }
+    if (!Array.isArray(content))
+        return null;
+    const parts = content.flatMap((item) => {
+        const part = asRecord(item);
+        if (!part)
+            return [];
+        if (stringValue(part.type) === "text") {
+            const text = stringValue(part.text);
+            if (!text || isSkillDefinition(text))
+                return [];
+            const cleaned = stripScaffolding(text);
+            return cleaned.length > 0 ? [cleaned] : [];
+        }
+        if (stringValue(part.type) === "tool_result") {
+            const toolUseId = stringValue(part.tool_use_id);
+            if (!toolUseId || !interactiveToolUseIds.has(toolUseId))
+                return [];
+            const text = extractToolResultText(part);
+            return text ? [text] : [];
+        }
+        return [];
+    });
+    return parts.length > 0 ? parts.join("\n") : null;
 }
 function firstLine(text) {
     return text.split(/\r?\n/, 1)[0]?.slice(0, 80) || "Claude Code conversation";
 }
+function trimmedTitle(value) {
+    const title = stringValue(value);
+    if (!title)
+        return null;
+    const trimmed = title.trim();
+    return trimmed.length > 0 ? trimmed.slice(0, 80) : null;
+}
+function isSkillDefinition(text) {
+    return text.trim().startsWith("Base directory for this skill:");
+}
+function stripScaffolding(text) {
+    let result = text;
+    for (const pattern of [
+        /<system_instruction>[\s\S]*?<\/system_instruction>/g,
+        /<system-instruction>[\s\S]*?<\/system-instruction>/g,
+        /<system-reminder>[\s\S]*?<\/system-reminder>/g,
+        /<local-command-caveat>[\s\S]*?<\/local-command-caveat>/g,
+        /<local-command-stdout>[\s\S]*?<\/local-command-stdout>/g,
+        /<command-name>[\s\S]*?<\/command-name>/g,
+        /<command-message>[\s\S]*?<\/command-message>/g,
+    ]) {
+        result = result.replace(pattern, "");
+    }
+    result = result.replace(/<command-args>([\s\S]*?)<\/command-args>/g, "$1");
+    while (result.includes("\n\n\n"))
+        result = result.replaceAll("\n\n\n", "\n\n");
+    return result.trim();
+}
+function extractAskUserQuestionText(block) {
+    const input = asRecord(block.input);
+    const questions = input?.questions;
+    if (!Array.isArray(questions))
+        return null;
+    const parts = questions.flatMap((item) => {
+        const question = asRecord(item);
+        const text = stringValue(question?.question);
+        if (!text)
+            return [];
+        const options = question?.options;
+        if (!Array.isArray(options))
+            return [text];
+        const formatted = options.flatMap((option, index) => {
+            const optionText = stringValue(option);
+            return optionText ? [`${String.fromCharCode(65 + index)}) ${optionText}`] : [];
+        });
+        return [formatted.length > 0 ? `${text}\n${formatted.join("\n")}` : text];
+    });
+    return parts.length > 0 ? parts.join("\n\n") : null;
+}
+function extractToolResultText(block) {
+    const content = block.content;
+    if (typeof content === "string" && content.length > 0)
+        return content;
+    if (!Array.isArray(content))
+        return null;
+    const texts = content.flatMap((item) => {
+        const record = asRecord(item);
+        const text = stringValue(record?.type) === "text" ? stringValue(record?.text) : null;
+        return text ? [text] : [];
+    });
+    return texts.length > 0 ? texts.join("\n") : null;
+}

package/dist/parser/codex.js

@@ -20,9 +20,9 @@ export async function parseCodexSession(path) {
             updatedAt = timestamp;
         }
         if (type === "session_meta") {
-            sessionId = stringValue(record.id) ?? stringValue(record.session_id) ?? sessionId;
-            title = redactTitle(stringValue(record.title)) ?? title;
             const meta = asRecord(record.payload) ?? record;
+            sessionId = stringValue(meta.id) ?? stringValue(record.id) ?? stringValue(record.session_id) ?? sessionId;
+            title = redactTitle(stringValue(record.title)) ?? title;
             cwd ??= stringValue(meta.cwd);
             continue;
         }
@@ -44,7 +44,7 @@ export async function parseCodexSession(path) {
     return {
         id: sessionId,
         sourceKind: "codex",
-        sourceId: path,
+        sourceId: sessionId,
         title: title ?? "Codex conversation",
         createdAt: createdAt ?? now,
         updatedAt: updatedAt ?? createdAt ?? now,
@@ -58,6 +58,8 @@ function roleForCodexMessage(messageType, payload) {
         return role;
     if (messageType?.includes("user"))
         return "user";
+    if (messageType === "task_complete")
+        return "assistant";
     if (messageType?.includes("agent") || messageType?.includes("assistant"))
         return "assistant";
     if (messageType?.includes("tool"))
@@ -70,6 +72,9 @@ function extractText(payload) {
         if (direct)
             return direct;
     }
+    const taskComplete = stringValue(payload.last_agent_message);
+    if (taskComplete)
+        return taskComplete;
     const message = asRecord(payload.message);
     if (message) {
         const content = stringValue(message.content);

package/dist/parser/types.js

@@ -6,4 +6,10 @@
  *
  * 1: workspace/repo metadata (cwd, git remote, repo key) on conversations.
  */
-export const PARSER_VERSION = 1;
+export const PARSER_VERSIONS = {
+    codex: 1,
+    claude_code: 1,
+};
+export function parserVersionForSourceKind(kind) {
+    return PARSER_VERSIONS[kind];
+}

package/dist/sync/client.js

@@ -1,9 +1,28 @@
-import { ApiError, postJson } from "../api/http.js";
+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 = {}) {
-    return postJsonWithRefresh(config, "/sync/v3/preflight", {
+    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,
@@ -14,19 +33,43 @@ export async function runPreflightV3(config, options = {}) {
             stableKey: source.stableKey,
             displayName: source.displayName,
         })),
-    }, options);
+    };
 }
 export async function pushSyncPayload(config, payload, options = {}) {
-    return postJsonWithRefresh(config, "/sync/v2/push", {
+    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 {
-        await postJson(syncApiUrl, path, body, { token, fetchImpl: options.fetchImpl });
-        return config;
+        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)
@@ -36,8 +79,8 @@ async function postJsonWithRefresh(config, path, body, options) {
     }
     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;
+    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;

package/dist/sync/exclusions.js

@@ -0,0 +1,10 @@
+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

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