@aixle/insights 0.2.1-staging → 0.2.1

package/dist/readers/claude.js

@@ -1,4 +1,5 @@
 import { createReadStream, statSync } from "node:fs";
+import { createHash } from "node:crypto";
 import { finished } from "node:stream/promises";
 import { createInterface } from "node:readline";
 import { join } from "node:path";
@@ -48,20 +49,30 @@ function isSecretEnvName(name) {
         return true;
     return /(?:^|_)(?:KEY|PASS|PWD)(?:_|$)/.test(n);
 }
+// A credential value that follows a flag or `=`: either a single/double quoted
+// string (which may contain spaces) or an unquoted run of non-space chars.
+const VALUE = String.raw `(?:"[^"]*"|'[^']*'|\S+)`;
+// Secret-bearing long-form flags. Matched with either `=` or a space separator,
+// and the value may be quoted (so `--token "secret value"` is fully redacted).
+const SECRET_FLAGS = "password|token|secret|api[-_]?key|access[-_]?key|auth[-_]?key|" +
+    "access-key-id|secret-access-key|service-account-key|client-secret";
 export function scrubBashCommand(cmd) {
     return (cmd
         // Authorization / Bearer / Basic headers (curl -H, fetch headers, etc.)
         .replace(/\b(Authorization\s*:\s*)(Bearer|Basic|Token)\s+\S+/gi, "$1$2 [REDACTED]")
-        // Inline env-var assignments carrying secrets (AWS_SECRET_ACCESS_KEY=…, db_password=…)
-        .replace(/\b([A-Za-z_][A-Za-z0-9_]*)\s*=\s*\S+/g, (match, name) => isSecretEnvName(name) ? `${name}=[REDACTED]` : match)
-        // --password=, --token=, --secret=, --api-key= flags
-        .replace(/(--(?:password|token|secret|api[-_]?key|access[-_]?key|auth[-_]?key)=)\S+/gi, "$1[REDACTED]")
-        // -p / --password <value> flag-value pairs
-        .replace(/((?:^|\s)-p\s+)\S+/g, "$1[REDACTED]")
+        // Inline env-var assignments carrying secrets (AWS_SECRET_ACCESS_KEY=…, db_password="a b").
+        // Value may be quoted so assignments with spaces inside quotes are fully redacted.
+        // eslint-disable-next-line security/detect-non-literal-regexp
+        .replace(new RegExp(String.raw `\b([A-Za-z_][A-Za-z0-9_]*)\s*=\s*${VALUE}`, "g"), (match, name) => isSecretEnvName(name) ? `${name}=[REDACTED]` : match)
+        // Secret flags in both --flag=value and --flag value forms, quoted or bare.
+        // eslint-disable-next-line security/detect-non-literal-regexp
+        .replace(new RegExp(String.raw `(--(?:${SECRET_FLAGS}))(=|\s+)${VALUE}`, "gi"), "$1$2[REDACTED]")
+        // -p / --password <value> flag-value pairs (value may be quoted)
+        // eslint-disable-next-line security/detect-non-literal-regexp
+        .replace(new RegExp(String.raw `((?:^|\s)-p\s+)${VALUE}`, "g"), "$1[REDACTED]")
         // AWS CLI --profile (may embed customer identifiers)
-        .replace(/(--profile\s+)\S+/g, "$1[REDACTED]")
-        // Cloud CLI credential flags: --access-key-id, --secret-access-key, --service-account-key
-        .replace(/(--(?:access-key-id|secret-access-key|service-account-key|client-secret)\s+)\S+/gi, "$1[REDACTED]")
+        // eslint-disable-next-line security/detect-non-literal-regexp
+        .replace(new RegExp(String.raw `(--profile\s+)${VALUE}`, "g"), "$1[REDACTED]")
         // curl | sh / curl | bash patterns (remote code execution)
         .replace(/\|\s*(sh|bash|zsh|dash)\b/g, "| [SHELL REDACTED]"));
 }
@@ -205,10 +216,29 @@ function newTurn(sessionId, turnIndex, filePath, fileSize, occurredAt, promptId)
         toolUses: [],
         navToolCalls: 0,
         totalToolCalls: 0,
-        messageIds: [],
+        contentHash: "",
         persisted: false,
     };
 }
+/**
+ * Stable fingerprint of a turn's emittable content. Includes the tool-use set
+ * (id + name + summary) so appending a tool_use to an already-synced turn
+ * changes the hash and triggers a re-emit (DB90DV-259).
+ */
+function computeTurnContentHash(turn) {
+    const toolFingerprint = turn.toolUses
+        .map((t) => `${t.id}:${t.eventType}:${t.summary}`)
+        .join("
");
+    const material = [
+        turn.model ?? "",
+        turn.tokensIn,
+        turn.tokensOut,
+        turn.promptText,
+        turn.assistantText,
+        toolFingerprint,
+    ].join("");
+    return createHash("sha256").update(material).digest("hex").slice(0, 32);
+}
 function appendText(existing, addition) {
     if (!addition.trim())
         return existing;
@@ -370,9 +400,6 @@ export async function parseTranscriptFile(filePath, verbose = false) {
                 }
                 if (entry.message.model)
                     currentTurn.model = entry.message.model;
-                if (entry.message.id && !currentTurn.messageIds.includes(entry.message.id)) {
-                    currentTurn.messageIds.push(entry.message.id);
-                }
                 currentTurn.occurredAt = timestamp > currentTurn.occurredAt ? timestamp : currentTurn.occurredAt;
                 const text = extractContentText(entry.message.content).join("\n\n").trim();
                 currentTurn.assistantText = appendText(currentTurn.assistantText, text);
@@ -391,7 +418,10 @@ export async function parseTranscriptFile(filePath, verbose = false) {
         return turns;
     }
     flushCurrentTurn();
-    return finalizedTurns.map(({ persisted: _persisted, ...turn }) => turn);
+    return finalizedTurns.map(({ persisted: _persisted, ...turn }) => ({
+        ...turn,
+        contentHash: computeTurnContentHash(turn),
+    }));
 }
 /** Converts a Claude transcript turn to parent chat and derivative tool-use payloads. */
 export function mapTranscriptTurn(turn, options) {
@@ -424,7 +454,6 @@ export function mapTranscriptTurn(turn, options) {
             // Zero is intentional: confirms no tool activity on this turn (not an omission).
             nav_tool_calls: turn.navToolCalls,
             total_tool_calls: turn.totalToolCalls,
-            message_ids: turn.messageIds.length > 0 ? turn.messageIds : undefined,
         },
     };
     if (turn.model)

package/dist/readers/cursor.d.ts

@@ -85,7 +85,7 @@ export interface PricingConfig {
     chat_output_per_mtok: number;
 }
 export declare const DEFAULT_CURSOR_PRICING: PricingConfig;
-export type CursorPayloadMetadata = {
+export type Db90CursorPayloadMetadata = {
     session_id?: string;
     cursor_session_id: string | null;
     workspace: string;
@@ -113,7 +113,7 @@ export type CursorPayloadMetadata = {
     duration_ms?: number;
     model_resolution?: "settings_json" | "state_vscdb" | "unresolved";
 };
-export interface CursorPayload extends IngestPayload {
+export interface CursorDb90Payload extends IngestPayload {
     tool_name: "cursor";
     event_type: "completion" | "chat" | "commit";
     model: string;
@@ -122,16 +122,16 @@ export interface CursorPayload extends IngestPayload {
     cost_usd: number;
     occurred_at: string;
     project_id?: string;
-    metadata: CursorPayloadMetadata;
+    metadata: Db90CursorPayloadMetadata;
 }
 export declare function toEpochMs(timestamp: number | string | null | undefined): number | null;
-export declare function mapDailyStats(entry: DailyStatsEntry, projectId?: string, pricing?: PricingConfig, model?: string, modelResolution?: CursorPayloadMetadata["model_resolution"]): CursorPayload[];
+export declare function mapDailyStats(entry: DailyStatsEntry, projectId?: string, pricing?: PricingConfig, model?: string, modelResolution?: Db90CursorPayloadMetadata["model_resolution"]): CursorDb90Payload[];
 /**
  * Maps Cursor’s latest-commit snapshot (`aiCodeTracking.recentCommit`) to a single commit-classified event.
  * Cursor only keeps one recent commit row (overwritten on each new commit).
  * Line-cost math still follows the chat-style line proxy (`computeLineCost("chat", …)`); only `event_type` differs.
  */
-export declare function mapRecentCommit(entry: RecentCommitSnapshot, projectId?: string, pricing?: PricingConfig, model?: string, modelResolution?: CursorPayloadMetadata["model_resolution"]): CursorPayload | null;
-export declare function mapEvent(row: CursorRow, workspacePath: string, projectId?: string, pricing?: PricingConfig): CursorPayload | null;
-export declare function mapTranscriptTurn(turn: CursorTranscriptTurn, projectId?: string, pricing?: PricingConfig, model?: string, modelResolution?: CursorPayloadMetadata["model_resolution"]): CursorPayload;
+export declare function mapRecentCommit(entry: RecentCommitSnapshot, projectId?: string, pricing?: PricingConfig, model?: string, modelResolution?: Db90CursorPayloadMetadata["model_resolution"]): CursorDb90Payload | null;
+export declare function mapEvent(row: CursorRow, workspacePath: string, projectId?: string, pricing?: PricingConfig): CursorDb90Payload | null;
+export declare function mapTranscriptTurn(turn: CursorTranscriptTurn, projectId?: string, pricing?: PricingConfig, model?: string, modelResolution?: Db90CursorPayloadMetadata["model_resolution"]): CursorDb90Payload;
 export {};

package/dist/readers/cursor.js

@@ -74,7 +74,10 @@ export function probeCursorGlobalStateDb(verbose = false, baseDir) {
 export function findCursorDbs(baseDir) {
     const dir = join(baseDir ?? cursorUserDir(), "workspaceStorage");
     try {
-        return glob.sync(join(dir, "**", "cursor.db"));
+        // Pattern stays forward-slash and the directory goes through `cwd`. Building
+        // it with `join` emitted `\` on Windows, and glob treats `\` as an escape
+        // character on every platform, so this silently matched nothing there.
+        return glob.sync("**/cursor.db", { cwd: dir, absolute: true });
     }
     catch {
         return [];
@@ -244,7 +247,14 @@ export function findStateVscDbs(baseDir) {
     const results = [];
     results.push(join(userDir, "globalStorage", "state.vscdb"));
     try {
-        results.push(...glob.sync(join(userDir, "workspaceStorage", "**", "state.vscdb")));
+        // Forward-slash pattern + `cwd`, as above. This one mattered most: the
+        // globalStorage path is pushed unconditionally, so on Windows the function
+        // still returned a result while silently dropping every per-workspace
+        // state.vscdb — partial data loss that looked like working software.
+        results.push(...glob.sync("workspaceStorage/**/state.vscdb", {
+            cwd: userDir,
+            absolute: true,
+        }));
     }
     catch {
         /* ignore */
@@ -451,8 +461,10 @@ function toIsoFromMs(value) {
 function coerceTranscriptTimestamp(value) {
     if (value == null)
         return null;
+    // Route numbers through toEpochMs (via toIsoString) so epoch *seconds* are scaled
+    // to ms — otherwise e.g. 1720000000 (2024 in seconds) is misread as a 1970 ms value.
     if (typeof value === "number")
-        return toIsoFromMs(value);
+        return toIsoString(value);
     if (typeof value !== "string")
         return null;
     const trimmed = value.trim();
@@ -707,17 +719,26 @@ export async function parseCursorTranscriptFile(filePath, composerHeaders, verbo
             if (texts.length === 0)
                 continue;
             if (entry.role === "user") {
+                // Normalize/filter before noting the time: a whitespace- or wrapper-only line
+                // must not set currentTurnOccurredAt (nor start a new turn) with nothing to append,
+                // otherwise the next real message inherits this stale timestamp.
+                const fragments = texts.map(stripUserQueryWrapper).filter((text) => text.length > 0);
+                if (fragments.length === 0)
+                    continue;
                 if (currentPromptParts.length > 0 || currentAssistantParts.length > 0) {
                     finalizeTurn();
                     currentPromptParts = [];
                     currentAssistantParts = [];
                 }
                 noteLineTime(entry);
-                currentPromptParts.push(...texts.map(stripUserQueryWrapper).filter((text) => text.length > 0));
+                currentPromptParts.push(...fragments);
             }
             else if (entry.role === "assistant") {
+                const fragments = texts.map((text) => text.trim()).filter((text) => text.length > 0);
+                if (fragments.length === 0)
+                    continue;
                 noteLineTime(entry);
-                currentAssistantParts.push(...texts.map((text) => text.trim()).filter((text) => text.length > 0));
+                currentAssistantParts.push(...fragments);
             }
         }
     }
@@ -864,7 +885,7 @@ export function mapDailyStats(entry, projectId, pricing = DEFAULT_CURSOR_PRICING
             eventType: "chat",
             tokensIn: composerSuggested,
             tokensOut: composerAccepted,
-            costUsd: computeLineCost("chat", composerSuggested, pricing),
+            costUsd: computeLineCost("chat", composerAccepted, pricing),
             occurredAt,
             dbPath,
             date,

package/dist/risk-scanner.js

@@ -12,6 +12,10 @@ const CATEGORIES = {
         weight: 3,
         patterns: [
             /\b\d{3}-\d{2}-\d{4}\b/g, // SSN
+            /* eslint-disable-next-line security/detect-unsafe-regex -- Flagged for
+               `{3}` inside `(?:…)?`. Every branch is a fixed-length digit run
+               anchored by \b, so the match is bounded and cannot backtrack
+               super-linearly. */
             /\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|6(?:011|5[0-9]{2})[0-9]{12}|(?:2131|1800|35\d{3})\d{11})\b/g, // Credit card
         ],
     },
@@ -19,6 +23,9 @@ const CATEGORIES = {
         weight: 1,
         patterns: [
             /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/gi, // Email
+            /* eslint-disable-next-line security/detect-unsafe-regex -- Flagged for
+               `?` nested in `?`. All quantified groups are fixed-length digit or
+               separator classes anchored by \b; matching is bounded. */
             /\b(?:\+?1[-.\s]?)?(?:\([0-9]{3}\)|[0-9]{3})[-.\s]?[0-9]{3}[-.\s]?[0-9]{4}\b/g, // Phone
         ],
     },

package/dist/server.d.ts

@@ -7,25 +7,8 @@ export declare const SYNC_NOW_INPUT_SCHEMA: z.ZodObject<{
         cursor: "cursor";
     }>>>;
 }, z.core.$strict>;
-/**
- * Whether a `credential_validation_failed` warning should mirror to stderr.
- * Mirrors for one-shot/startup sources so an installed-but-uninitialized MCP is
- * visible, but NOT for the recurring background `"interval"` tick — that fires
- * every SYNC_INTERVAL_MS for the whole process lifetime and would spam the logs.
- * The event is always written to mcp.log regardless of this return value.
- */
-export declare function shouldMirrorMissingCredentials(source: string): boolean;
 /** Structured status for `aixle_insights_status` — tolerates missing/malformed credentials and state. */
 export declare function buildAixleInsightsStatusPayload(): Promise<Record<string, unknown>>;
 /** In-process MCP server instance (stdio not attached). */
 export declare function createAixleInsightsMcpServer(): McpServer;
-/**
- * Subscribes `shutdown` to the given stream's "end" and "close" events.
- * Closing stdin is how the OS signals a stdio-transport MCP server that its
- * parent process is gone — this fires even when the parent can't deliver a
- * signal (e.g. it was itself SIGKILL'd, or the OS reparented this process
- * without ever sending one). Exported standalone so it's testable with a
- * plain EventEmitter instead of the real process.stdin.
- */
-export declare function wireParentExitShutdown(stdin: Pick<NodeJS.ReadStream, "on">, shutdown: () => void): void;
 export declare function startServer(): Promise<void>;

package/dist/server.js

@@ -62,16 +62,6 @@ function migrateAllLegacyState(creds) {
 function syncResultOk(result) {
     return !result.locked && result.failed === 0;
 }
-/**
- * Whether a `credential_validation_failed` warning should mirror to stderr.
- * Mirrors for one-shot/startup sources so an installed-but-uninitialized MCP is
- * visible, but NOT for the recurring background `"interval"` tick — that fires
- * every SYNC_INTERVAL_MS for the whole process lifetime and would spam the logs.
- * The event is always written to mcp.log regardless of this return value.
- */
-export function shouldMirrorMissingCredentials(source) {
-    return source !== "interval";
-}
 // Process-lifetime cache keyed on the inputs that drive resolveProjectId: host,
 // lookup token, and the current repo's git remote. Re-resolve when any of them
 // changes (re-auth, repo cwd change). `source: "none"` is never cached so a
@@ -101,7 +91,7 @@ export async function buildAixleInsightsStatusPayload() {
 async function executeSync(parsed) {
     const creds = await loadCredentials();
     if (!creds || !credentialsHaveAnyToken(creds)) {
-        mcpLog.warn("credential_validation_failed", { source: "aixle_insights_sync_now", reason: "missing_credentials" }, shouldMirrorMissingCredentials("aixle_insights_sync_now"));
+        mcpLog.warn("credential_validation_failed", { source: "aixle_insights_sync_now", reason: "missing_credentials" }, false);
         return { ok: false, error: "missing_credentials" };
     }
     migrateAllLegacyState(creds);
@@ -196,18 +186,6 @@ export function createAixleInsightsMcpServer() {
     }, authenticateHandler);
     return server;
 }
-/**
- * Subscribes `shutdown` to the given stream's "end" and "close" events.
- * Closing stdin is how the OS signals a stdio-transport MCP server that its
- * parent process is gone — this fires even when the parent can't deliver a
- * signal (e.g. it was itself SIGKILL'd, or the OS reparented this process
- * without ever sending one). Exported standalone so it's testable with a
- * plain EventEmitter instead of the real process.stdin.
- */
-export function wireParentExitShutdown(stdin, shutdown) {
-    stdin.on("end", shutdown);
-    stdin.on("close", shutdown);
-}
 export async function startServer() {
     const server = createAixleInsightsMcpServer();
     const transport = new StdioServerTransport();
@@ -228,13 +206,12 @@ export async function startServer() {
     };
     process.on("SIGINT", onSignal);
     process.on("SIGTERM", onSignal);
-    wireParentExitShutdown(process.stdin, onSignal);
     const runBackground = async (source) => {
         if (shuttingDown)
             return;
         const creds = await loadCredentials();
         if (!creds || !credentialsHaveAnyToken(creds)) {
-            mcpLog.warn("credential_validation_failed", { source, reason: "missing_credentials" }, shouldMirrorMissingCredentials(source));
+            mcpLog.warn("credential_validation_failed", { source, reason: "missing_credentials" }, false);
             return;
         }
         try {

package/dist/state.js

@@ -3,6 +3,7 @@ import { join } from "node:path";
 import { homedir } from "node:os";
 import { createHash, randomBytes } from "node:crypto";
 import { mcpLog } from "./log.js";
+import { describeReadFailure } from "./lib/parse-error.js";
 export function getAppDir() {
     const override = process.env["AIXLE_INSIGHTS_HOME"]?.trim();
     if (override && override.length > 0)
@@ -90,48 +91,50 @@ export function migrateLegacyState(dir, host, token) {
 }
 export function readState(dir, host, token) {
     const filePath = stateFilePath(dir ?? getAppDir(), host, token);
+    let parsed;
     try {
-        const parsed = JSON.parse(readFileSync(filePath, "utf-8"));
-        if (typeof parsed === "object" && parsed !== null) {
-            const p = parsed;
-            if (typeof p.version === "number" &&
-                typeof p.sessions === "object" &&
-                p.sessions !== null) {
-                const lastRecentCommitHashes = Array.isArray(p.lastRecentCommitHashes)
-                    ? p.lastRecentCommitHashes.filter((h) => typeof h === "string")
-                    : undefined;
-                const out = {
-                    version: p.version,
-                    sessions: p.sessions,
-                };
-                if (lastRecentCommitHashes !== undefined) {
-                    out.lastRecentCommitHashes = lastRecentCommitHashes;
-                }
-                if ("mcp_operator" in p) {
-                    const mcp = parseMcpOperator(p.mcp_operator);
-                    if (mcp)
-                        out.mcp_operator = mcp;
-                }
-                if ("rate_limited_until" in p) {
-                    if (typeof p.rate_limited_until === "string") {
-                        out.rate_limited_until = p.rate_limited_until;
-                    }
-                    else if (p.rate_limited_until === null) {
-                        out.rate_limited_until = null;
-                    }
-                }
-                return out;
-            }
-        }
+        parsed = JSON.parse(readFileSync(filePath, "utf-8"));
     }
     catch (err) {
         const code = err?.code;
         if (code !== "ENOENT") {
-            // State file exists but failed to parse — distinguishes tampering from "never created".
-            mcpLog.warn("state_parse_failed", { path: filePath, error: err instanceof Error ? err.message : String(err) }, false);
+            // State file exists but is not valid JSON — distinguishes tampering from "never created".
+            // ENOENT stays silent: that is the normal first-run case.
+            mcpLog.warn("state_parse_failed", { path: filePath, ...describeReadFailure(err) }, false);
+        }
+        return { version: 1, sessions: {} };
+    }
+    const p = typeof parsed === "object" && parsed !== null ? parsed : null;
+    if (p === null || typeof p.version !== "number" || typeof p.sessions !== "object" || p.sessions === null) {
+        // Valid JSON, wrong shape. This fallback discards every dedup checkpoint and causes a full
+        // re-send, so it is the most consequential of the four to have been silent. (DB90DV-699)
+        mcpLog.warn("state_parse_failed", { path: filePath, reason: "invalid_shape" }, false);
+        return { version: 1, sessions: {} };
+    }
+    const lastRecentCommitHashes = Array.isArray(p.lastRecentCommitHashes)
+        ? p.lastRecentCommitHashes.filter((h) => typeof h === "string")
+        : undefined;
+    const out = {
+        version: p.version,
+        sessions: p.sessions,
+    };
+    if (lastRecentCommitHashes !== undefined) {
+        out.lastRecentCommitHashes = lastRecentCommitHashes;
+    }
+    if ("mcp_operator" in p) {
+        const mcp = parseMcpOperator(p.mcp_operator);
+        if (mcp)
+            out.mcp_operator = mcp;
+    }
+    if ("rate_limited_until" in p) {
+        if (typeof p.rate_limited_until === "string") {
+            out.rate_limited_until = p.rate_limited_until;
+        }
+        else if (p.rate_limited_until === null) {
+            out.rate_limited_until = null;
         }
     }
-    return { version: 1, sessions: {} };
+    return out;
 }
 /** Atomic write: write to a temp file then rename over the target. */
 export function writeState(state, dir, host, token) {

package/dist/sync.d.ts

@@ -2,7 +2,7 @@ import type { TelemetryToolId, StoredCredentials } from "./auth/credentials.js";
 import { type PricingTable } from "./pricing.js";
 import type { PricingConfig } from "./readers/cursor.js";
 import { type ProjectResolution } from "./lib/index.js";
-import type { CursorPayload } from "./readers/cursor.js";
+import type { CursorDb90Payload } from "./readers/cursor.js";
 /** Prefix for Claude Code session keys in shared MCP state. */
 export declare const CLAUDE_STATE_PREFIX: "claude_code:";
 export { CURSOR_WATERMARK_KEY, CURSOR_EVENTS_WATERMARK_KEY, CURSOR_DAILY_STATS_WATERMARK_KEY, CURSOR_RECENT_COMMIT_WATERMARK_KEY, CURSOR_TRANSCRIPT_TURN_PREFIX, cursorTranscriptTurnStateKey, filterRecentCommitsByHashDedup, } from "./cursor-checkpoints.js";
@@ -67,7 +67,16 @@ export declare function getSyncTelemetry(): {
     lastResult: SyncResult | null;
     recentErrors: string[];
 };
-export declare function cursorRepoPathFromPayload(payload: CursorPayload): string | undefined;
+/**
+ * The repo path for a Cursor payload, normalized and safe to hand to project
+ * resolution. Returns an absolute, `..`-collapsed path or undefined.
+ *
+ * `workspace_folder` comes from the workspace's own `workspace.json` and
+ * `workspace` from a composer `uri.fsPath` or the `state.vscdb` path — all
+ * untrusted. When the preferred field is unusable we fall through to the other
+ * rather than giving up. See DB90DV-547.
+ */
+export declare function cursorRepoPathFromPayload(payload: CursorDb90Payload): string | undefined;
 /**
  * Parallel multi-tool cycle under the global advisory ingest lock (`state.lock`).
  */

package/dist/sync.js

@@ -11,6 +11,7 @@ import { postEvent, postEvents } from "./client.js";
 import { getCostWarning } from "./pricing.js";
 import { acquireSyncLock } from "./lock.js";
 import { getGitRemoteForPath, lookupProjectByRemote, } from "./lib/index.js";
+import { isRepoPathWithinRoot, normalizeRepoPathCandidate, } from "./lib/repo-path-safety.js";
 import { mcpLog } from "./log.js";
 /** Prefix for Claude Code session keys in shared MCP state. */
 export const CLAUDE_STATE_PREFIX = "claude_code:";
@@ -103,8 +104,8 @@ function explicitProjectId(projectId, projectIdSource) {
         : undefined;
 }
 async function resolveProjectIdForRepoPathCached(repoPath, host, token, verbose, cache, allowInsecureHttp = false) {
-    const normalized = repoPath?.trim();
-    if (!normalized)
+    const normalized = normalizeRepoPathCandidate(repoPath);
+    if (normalized === null)
         return null;
     if (cache.has(normalized))
         return cache.get(normalized) ?? null;
@@ -118,15 +119,25 @@ async function resolveProjectIdForRepoPathCached(repoPath, host, token, verbose,
     cache.set(normalized, projectId);
     return projectId;
 }
+/**
+ * The repo path for a Cursor payload, normalized and safe to hand to project
+ * resolution. Returns an absolute, `..`-collapsed path or undefined.
+ *
+ * `workspace_folder` comes from the workspace's own `workspace.json` and
+ * `workspace` from a composer `uri.fsPath` or the `state.vscdb` path — all
+ * untrusted. When the preferred field is unusable we fall through to the other
+ * rather than giving up. See DB90DV-547.
+ */
 export function cursorRepoPathFromPayload(payload) {
     const metadata = payload.metadata;
     if (!metadata)
         return undefined;
-    if (typeof metadata.workspace_folder === "string" && metadata.workspace_folder.length > 0) {
-        return metadata.workspace_folder;
-    }
-    if (typeof metadata.workspace === "string" && metadata.workspace.length > 0) {
-        return metadata.workspace;
+    for (const candidate of [metadata.workspace_folder, metadata.workspace]) {
+        if (typeof candidate !== "string")
+            continue;
+        const normalized = normalizeRepoPathCandidate(candidate);
+        if (normalized !== null)
+            return normalized;
     }
     return undefined;
 }
@@ -194,21 +205,27 @@ async function runClaudeSlice(options) {
             mcpLog.info("sync_noise_skip", { tool: "claude_code", reason: "local_command_noise" }, false);
             continue;
         }
-        // When scopeDir is set, skip turns from other directories.
+        // When scopeDir is set, skip turns from other directories. `turn.cwd` is an
+        // arbitrary string from a transcript JSONL, so a plain prefix match would
+        // accept `<scopeDir>/../../elsewhere` (DB90DV-547).
         if (scopeDir) {
-            const cwd = turn.cwd?.trim();
-            const inScope = cwd && (cwd === scopeDir || cwd.startsWith(scopeDir + "/"));
+            const cwd = normalizeRepoPathCandidate(turn.cwd);
+            const inScope = cwd !== null && isRepoPathWithinRoot(cwd, scopeDir);
             if (!inScope) {
                 totalSkipped++;
                 if (verbose) {
-                    console.log(`[verbose] Skipping Claude turn ${turn.turnId} — cwd=${cwd ?? "(none)"} not under scopeDir=${scopeDir}`);
+                    console.log(`[verbose] Skipping Claude turn ${turn.turnId} — cwd=${turn.cwd ?? "(none)"} not under scopeDir=${scopeDir}`);
                 }
                 continue;
             }
         }
         const sKey = sessionStateKey(turn.turnId);
         const known = state.sessions[sKey];
-        if (known) {
+        // A turn keeps its turnId as Claude appends more tool_use blocks to it, so a
+        // plain "already known → skip" would drop derivatives appended after an earlier
+        // mid-turn sync. Skip only when the content fingerprint is unchanged; otherwise
+        // re-emit so the newly appended tool uses are sent (DB90DV-259).
+        if (known && known.contentHash && known.contentHash === turn.contentHash) {
             totalSkipped++;
             if (verbose) {
                 console.log(`[verbose] Skipping already-synced Claude turn ${turn.turnId}`);
@@ -257,6 +274,7 @@ async function runClaudeSlice(options) {
                 console.log(`[verbose] Sending Claude ${payload.event_type} ${payload.metadata.session_id}`);
             }
             const ok = await postEvent(payload, host, token, {
+                allowInsecureHttp,
                 on429: (retryAfter, quotaExceeded) => {
                     const currentBackoff = backoffUntilByCredential.get(backoffKey);
                     const nextBackoff = new Date(Math.max(currentBackoff?.getTime() ?? 0, Date.now() + retryAfter * 1000));
@@ -284,7 +302,7 @@ async function runClaudeSlice(options) {
         }
         if (allOk) {
             totalSent += payloads.length;
-            state = markSessionSent(state, sKey, turn.fileSize);
+            state = markSessionSent(state, sKey, turn.fileSize, turn.contentHash);
             writeState(state, appDir, host, token);
         }
         else if (shouldStopForBackoff) {
@@ -353,7 +371,7 @@ async function runCursorSlice(params) {
             const inScope = [];
             for (const payload of group.payloads) {
                 const ws = cursorRepoPathFromPayload(payload);
-                if (ws && (ws === scopeDir || ws.startsWith(scopeDir + "/"))) {
+                if (ws && isRepoPathWithinRoot(ws, scopeDir)) {
                     // Same fallback as Claude: when the pre-resolved projectId is null, do a
                     // per-payload lookup from the payload's workspace. Cache dedupes by path.
                     const resolved = projectId ??

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aixle/insights",
-  "version": "0.2.1-staging",
+  "version": "0.2.1",
   "description": "stdio MCP server for AI coding-assistant telemetry — Claude transcript sync + Cursor SQLite ingest.",
   "type": "module",
   "bin": {
@@ -19,7 +19,7 @@
     "provenance": false
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=20.19.0"
   },
   "license": "MIT",
   "repository": {
@@ -43,6 +43,7 @@
   "scripts": {
     "build": "tsc && node -e \"const{mkdirSync,copyFileSync}=require('fs');mkdirSync('dist/hooks',{recursive:true});copyFileSync('src/hooks/hook-forwarder.mjs','dist/hooks/hook-forwarder.mjs');\"",
     "test": "vitest run",
+    "lint": "eslint . --max-warnings 0",
     "verify:cursor-dry-run": "tsx scripts/verify-cursor-dry-run.ts",
     "audit:local-stores": "tsx scripts/audit-local-stores.ts",
     "dev": "tsx src/cli.ts",
@@ -51,7 +52,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "better-sqlite3": "^12.9.0",
-    "glob": "^10.5.0",
+    "glob": "^13.0.6",
     "zod": "^3.23.0 || ^4.0.0"
   },
   "optionalDependencies": {
@@ -60,8 +61,11 @@
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.8",
     "@types/node": "^24",
+    "@typescript-eslint/parser": "^8.65.0",
+    "eslint": "^10.8.0",
+    "eslint-plugin-security": "^4.0.1",
     "tsx": "^4.7.0",
     "typescript": "^5.3.3",
-    "vitest": "^4.1.0"
+    "vitest": "4.1.9"
   }
 }

package/dist/install/cursor.d.ts

@@ -1,34 +0,0 @@
-import { type InstallResult } from "./claude.js";
-export interface InstallCursorUserMcpOptions {
-    /** Tests: full path to the Cursor MCP config file (default ~/.cursor/mcp.json). */
-    cursorConfigPath?: string;
-    force?: boolean;
-}
-export type UninstallResult = {
-    kind: "restored";
-    backupPath: string;
-} | {
-    kind: "removed";
-} | {
-    kind: "noop";
-} | {
-    kind: "error";
-    message: string;
-};
-export declare function defaultCursorUserConfigPath(): string;
-/**
- * Merges top-level `mcpServers.aixle-insights` into ~/.cursor/mcp.json (or overridden path).
- * Preserves all other keys and MCP server entries. Backs up the existing file
- * (once) before the first write, and removes legacy "db90"/"insights" keys so
- * Cursor does not spawn duplicate aixle-insights servers.
- */
-export declare function installCursorUserMcp(options?: InstallCursorUserMcpOptions): InstallResult;
-/**
- * Removes the aixle-insights entry from ~/.cursor/mcp.json without disturbing any
- * other server entry — including ones the user or Cursor added after install.
- * Works on the CURRENT file (never a full-file revert to the backup). If a
- * pre-install backup exists, the user's ORIGINAL aixle-insights entry (if any)
- * is restored from it; otherwise our key is simply removed. The backup file is
- * cleaned up either way.
- */
-export declare function uninstallCursorUserMcp(options?: InstallCursorUserMcpOptions): UninstallResult;