@meterbility/cursor-adapter 0.3.1

package/LICENSE

@@ -0,0 +1,33 @@
+MIT License
+
+Copyright (c) 2026 Meterbility authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+----------------------------------------------------------------------
+
+Note: This MIT license covers everything in this repository EXCEPT the
+contents of the /ee directory (when present), which are licensed under the
+Elastic License 2.0 (ELv2) — see /ee/LICENSE.
+
+The /ee directory is reserved for Enterprise Edition modules: multi-tenant
+fleet orchestration, SSO/RBAC, audit logs, and long-retention features.
+
+Nothing under /ee today; the directory is created as a forward-compatible
+marker so the licensing boundary is visible before any /ee code lands.

package/README.md

@@ -0,0 +1,11 @@
+# @meterbility/cursor-adapter
+
+Part of [Meterbility](https://github.com/HoneycombHairDevelopers/Meterbility) — the debugger for AI agents. Capture every run, inspect every decision, pause and inject live, fork from any step.
+
+Ingests Cursor composer conversations from Cursor's global storage database.
+
+```bash
+npm install @meterbility/cursor-adapter
+```
+
+See the [Meterbility documentation](https://github.com/HoneycombHairDevelopers/Meterbility#readme) for the full guide. MIT licensed.

package/dist/chunk-755T3Z3H.js

@@ -0,0 +1,88 @@
+// src/discover.ts
+import { readdir, stat } from "fs/promises";
+import { existsSync } from "fs";
+import { homedir, platform } from "os";
+import { join } from "path";
+function cursorPaths() {
+  if (process.env.CURSOR_USER_DIR) {
+    return {
+      globalStorage: join(process.env.CURSOR_USER_DIR, "globalStorage"),
+      workspaceStorage: join(process.env.CURSOR_USER_DIR, "workspaceStorage"),
+      globalDb: join(process.env.CURSOR_USER_DIR, "globalStorage", "state.vscdb")
+    };
+  }
+  const home = homedir();
+  let userDir;
+  switch (platform()) {
+    case "darwin":
+      userDir = join(home, "Library", "Application Support", "Cursor", "User");
+      break;
+    case "win32":
+      userDir = join(
+        process.env.APPDATA ?? join(home, "AppData", "Roaming"),
+        "Cursor",
+        "User"
+      );
+      break;
+    default:
+      userDir = join(home, ".config", "Cursor", "User");
+  }
+  return {
+    globalStorage: join(userDir, "globalStorage"),
+    workspaceStorage: join(userDir, "workspaceStorage"),
+    globalDb: join(userDir, "globalStorage", "state.vscdb")
+  };
+}
+async function discoverCursorWorkspaces() {
+  const root = cursorPaths().workspaceStorage;
+  const out = [];
+  let entries;
+  try {
+    entries = await readdir(root);
+  } catch {
+    return out;
+  }
+  for (const e of entries) {
+    const full = join(root, e);
+    let s;
+    try {
+      s = await stat(full);
+    } catch {
+      continue;
+    }
+    if (!s.isDirectory()) continue;
+    const wsJson = join(full, "workspace.json");
+    out.push({
+      workspace_id: e,
+      path: full,
+      size_bytes: s.size,
+      mtime: s.mtime,
+      workspace_json: existsSync(wsJson) ? wsJson : void 0
+    });
+  }
+  out.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+  return out;
+}
+async function readWorkspaceCwd(ws) {
+  if (!ws.workspace_json) return void 0;
+  try {
+    const { readFile } = await import("fs/promises");
+    const buf = await readFile(ws.workspace_json, "utf-8");
+    const obj = JSON.parse(buf);
+    if (typeof obj.folder === "string") {
+      return obj.folder.replace(/^file:\/\//, "");
+    }
+  } catch {
+  }
+  return void 0;
+}
+function defaultGlobalDbPath() {
+  return cursorPaths().globalDb;
+}
+
+export {
+  cursorPaths,
+  discoverCursorWorkspaces,
+  readWorkspaceCwd,
+  defaultGlobalDbPath
+};

package/dist/discover-OXMJMPOW.js

@@ -0,0 +1,12 @@
+import {
+  cursorPaths,
+  defaultGlobalDbPath,
+  discoverCursorWorkspaces,
+  readWorkspaceCwd
+} from "./chunk-755T3Z3H.js";
+export {
+  cursorPaths,
+  defaultGlobalDbPath,
+  discoverCursorWorkspaces,
+  readWorkspaceCwd
+};

package/dist/index.d.ts

@@ -0,0 +1,193 @@
+import { Store } from '@meterbility/collector';
+
+/**
+ * Cursor's chat content lives in **global** storage, not workspace
+ * storage:
+ *
+ *   macOS:   ~/Library/Application Support/Cursor/User/globalStorage/state.vscdb
+ *   Linux:   ~/.config/Cursor/User/globalStorage/state.vscdb
+ *   Windows: %APPDATA%\Cursor\User\globalStorage\state.vscdb
+ *
+ * Workspace storage holds layout state but not bubbles.
+ */
+interface CursorPaths {
+    globalStorage: string;
+    workspaceStorage: string;
+    globalDb: string;
+}
+declare function cursorPaths(): CursorPaths;
+interface DiscoveredCursorWorkspace {
+    workspace_id: string;
+    path: string;
+    size_bytes: number;
+    mtime: Date;
+    /** Path to its workspace.json which often contains the original folder URI. */
+    workspace_json?: string;
+}
+/**
+ * Walk workspaceStorage to map workspace_ids back to source directories
+ * (so we can attribute composers to projects). Doesn't itself contain
+ * chat bubbles.
+ */
+declare function discoverCursorWorkspaces(): Promise<DiscoveredCursorWorkspace[]>;
+/** Extract the cwd of a workspace from its workspace.json (best-effort). */
+declare function readWorkspaceCwd(ws: DiscoveredCursorWorkspace): Promise<string | undefined>;
+declare function defaultGlobalDbPath(): string;
+
+/**
+ * Cursor's cursorDiskKV schema (reverse-engineered from the global
+ * `state.vscdb` shipped with Cursor 2.x). Three key prefixes carry the
+ * conversation surface:
+ *
+ *   composerData:<composerId>            — conversation envelope + index
+ *   bubbleId:<composerId>:<bubbleId>     — one message (user or assistant)
+ *   messageRequestContext:<composerId>:<requestId>  — provider-side request bytes
+ *
+ * Cursor changes these schemas without notice. The adapter probes for the
+ * keys it knows and degrades gracefully when fields are missing.
+ */
+/** type=1 = user, type=2 = assistant. */
+type CursorBubbleType = 1 | 2;
+interface CursorConversationHeader {
+    bubbleId: string;
+    type: CursorBubbleType;
+    serverBubbleId?: string;
+}
+interface CursorComposerData {
+    _v?: number;
+    composerId: string;
+    name?: string;
+    subtitle?: string;
+    unifiedMode?: number | string;
+    forceMode?: string;
+    status?: string;
+    text?: string;
+    richText?: string;
+    fullConversationHeadersOnly?: CursorConversationHeader[];
+    conversationMap?: Record<string, unknown>;
+    context?: Record<string, unknown>;
+    capabilities?: unknown[];
+    modelConfig?: Record<string, unknown>;
+    usageData?: Record<string, unknown>;
+    contextUsagePercent?: number;
+    totalLinesAdded?: number;
+    totalLinesRemoved?: number;
+    createdAt?: number;
+    lastUpdatedAt?: number;
+    isArchived?: boolean;
+    hasUnreadMessages?: boolean;
+}
+interface CursorTokenCount {
+    inputTokens?: number;
+    outputTokens?: number;
+}
+interface CursorToolFormerData {
+    /** Cursor encodes the tool kind both as a numeric `tool` index and a
+     *  human-readable `name`. We rely on `name`. */
+    tool?: number;
+    name?: string;
+    toolCallId?: string;
+    modelCallId?: string;
+    status?: "completed" | "errored" | "pending" | string;
+    /** JSON-encoded args as the model emitted them. */
+    rawArgs?: string;
+    /** Parsed/effective args after Cursor's normalization. */
+    params?: string;
+    /** Tool result body (often a stringified blob). */
+    result?: unknown;
+    additionalData?: unknown;
+}
+interface CursorThinkingBlock {
+    text?: string;
+    signature?: string;
+    redacted?: boolean;
+}
+interface CursorBubble {
+    _v?: number;
+    bubbleId: string;
+    type: CursorBubbleType;
+    text?: string;
+    richText?: string;
+    createdAt?: string;
+    requestId?: string;
+    tokenCount?: CursorTokenCount;
+    toolFormerData?: CursorToolFormerData;
+    allThinkingBlocks?: CursorThinkingBlock[];
+    toolResults?: unknown[];
+    codeBlocks?: unknown[];
+    attachedCodeChunks?: unknown[];
+    context?: Record<string, unknown>;
+    capabilityType?: number;
+}
+declare function isUserBubble(b: CursorBubble): boolean;
+declare function isAssistantBubble(b: CursorBubble): boolean;
+declare function bubbleText(b: CursorBubble): string;
+
+/**
+ * Read-only SQLite client for Cursor's `state.vscdb`. We always open
+ * with `readonly: true` and `fileMustExist: true` so we cannot
+ * accidentally mutate Cursor's state.
+ */
+declare class CursorDb {
+    private db;
+    constructor(path: string);
+    close(): void;
+    /**
+     * Fetch every composerId we can see in cursorDiskKV. Returns the
+     * envelopes (without bubble bodies) for cheap iteration.
+     */
+    listComposers(): CursorComposerData[];
+    getComposer(composerId: string): CursorComposerData | undefined;
+    getBubble(composerId: string, bubbleId: string): CursorBubble | undefined;
+    /**
+     * Walk the conversation in canonical order, returning bubbles in the
+     * order Cursor records in `fullConversationHeadersOnly`. Missing
+     * bubbles (deleted, or written-but-not-flushed) are skipped.
+     */
+    iterBubbles(composer: CursorComposerData): Iterable<CursorBubble>;
+    /** Schema sanity check — used by doctor and tests. */
+    hasCursorDiskKV(): boolean;
+    /** Total number of cursorDiskKV rows by prefix; useful for diagnostics. */
+    prefixCounts(): Record<string, number>;
+}
+declare function headerCount(c: CursorComposerData): number;
+declare function isMeaningfulComposer(c: CursorComposerData): boolean;
+declare function _conversationHeader(c: CursorComposerData, bubbleId: string): CursorConversationHeader | undefined;
+
+interface CursorIngestResult {
+    workspace_id?: string;
+    composers_seen: number;
+    composers_ingested: number;
+    steps_added: number;
+    status: "ok" | "no_db" | "no_composers";
+    reason?: string;
+}
+interface IngestCursorOptions {
+    /** Override the path to Cursor's global state.vscdb. */
+    dbPath?: string;
+    /** Restrict to one composer id. */
+    composerId?: string;
+    /** Skip composers older than this (epoch ms). */
+    sinceMs?: number;
+    /** Only ingest the N newest composers. */
+    limit?: number;
+    /** Project cwd to attribute the run to (defaults to "(cursor)"). */
+    cwd?: string;
+}
+/**
+ * Ingest Cursor composer conversations from the global state.vscdb.
+ *
+ * Each composer becomes one Meterbility Run. Each bubble becomes one Step:
+ *   - user bubbles (type=1) become "message" steps with the user text
+ *     as the action.
+ *   - assistant bubbles (type=2) become either tool_call steps (when
+ *     `toolFormerData` is present) or message steps (when `text` is
+ *     non-empty).
+ *
+ * Cursor doesn't expose system prompts in the SQLite (they're injected
+ * server-side), and per-step token usage is sparse. We capture what we
+ * can and tag steps with `cost:approx` where cost is a wild estimate.
+ */
+declare function ingestCursorGlobal(store: Store, opts?: IngestCursorOptions): Promise<CursorIngestResult>;
+
+export { type CursorBubble, type CursorBubbleType, type CursorComposerData, type CursorConversationHeader, CursorDb, type CursorIngestResult, type CursorPaths, type CursorThinkingBlock, type CursorTokenCount, type CursorToolFormerData, type DiscoveredCursorWorkspace, type IngestCursorOptions, _conversationHeader, bubbleText, cursorPaths, defaultGlobalDbPath, discoverCursorWorkspaces, headerCount, ingestCursorGlobal, isAssistantBubble, isMeaningfulComposer, isUserBubble, readWorkspaceCwd };

package/dist/index.js

@@ -0,0 +1,431 @@
+import {
+  cursorPaths,
+  defaultGlobalDbPath,
+  discoverCursorWorkspaces,
+  readWorkspaceCwd
+} from "./chunk-755T3Z3H.js";
+
+// src/types.ts
+function isUserBubble(b) {
+  return b.type === 1;
+}
+function isAssistantBubble(b) {
+  return b.type === 2;
+}
+function bubbleText(b) {
+  if (b.text && b.text.length > 0) return b.text;
+  if (b.richText) {
+    try {
+      return extractLexicalText(JSON.parse(b.richText));
+    } catch {
+      return "";
+    }
+  }
+  return "";
+}
+function extractLexicalText(root) {
+  const out = [];
+  const walk = (n) => {
+    if (!n || typeof n !== "object") return;
+    const node = n;
+    if (node.root) walk(node.root);
+    if (typeof node.text === "string") out.push(node.text);
+    if (node.children) for (const c of node.children) walk(c);
+  };
+  walk(root);
+  return out.join("");
+}
+
+// src/parser.ts
+import Database from "better-sqlite3";
+var CursorDb = class {
+  db;
+  constructor(path) {
+    this.db = new Database(path, { readonly: true, fileMustExist: true });
+  }
+  close() {
+    this.db.close();
+  }
+  /**
+   * Fetch every composerId we can see in cursorDiskKV. Returns the
+   * envelopes (without bubble bodies) for cheap iteration.
+   */
+  listComposers() {
+    const rows = this.db.prepare(
+      "SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'"
+    ).all();
+    const out = [];
+    for (const row of rows) {
+      try {
+        const parsed = JSON.parse(row.value);
+        if (parsed && typeof parsed === "object" && typeof parsed.composerId === "string") {
+          out.push(parsed);
+        }
+      } catch {
+      }
+    }
+    return out;
+  }
+  getComposer(composerId) {
+    const row = this.db.prepare("SELECT value FROM cursorDiskKV WHERE key = ?").get(`composerData:${composerId}`);
+    if (!row) return void 0;
+    try {
+      return JSON.parse(row.value);
+    } catch {
+      return void 0;
+    }
+  }
+  getBubble(composerId, bubbleId) {
+    const row = this.db.prepare("SELECT value FROM cursorDiskKV WHERE key = ?").get(`bubbleId:${composerId}:${bubbleId}`);
+    if (!row) return void 0;
+    try {
+      return JSON.parse(row.value);
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Walk the conversation in canonical order, returning bubbles in the
+   * order Cursor records in `fullConversationHeadersOnly`. Missing
+   * bubbles (deleted, or written-but-not-flushed) are skipped.
+   */
+  *iterBubbles(composer) {
+    const headers = composer.fullConversationHeadersOnly ?? [];
+    for (const h of headers) {
+      const b = this.getBubble(composer.composerId, h.bubbleId);
+      if (b) yield b;
+    }
+  }
+  /** Schema sanity check — used by doctor and tests. */
+  hasCursorDiskKV() {
+    const r = this.db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='cursorDiskKV'"
+    ).get();
+    return r !== void 0;
+  }
+  /** Total number of cursorDiskKV rows by prefix; useful for diagnostics. */
+  prefixCounts() {
+    const rows = this.db.prepare(
+      "SELECT substr(key, 1, instr(key, ':') - 1) AS prefix, COUNT(*) AS n FROM cursorDiskKV GROUP BY prefix"
+    ).all();
+    const out = {};
+    for (const r of rows) out[r.prefix] = r.n;
+    return out;
+  }
+};
+function headerCount(c) {
+  return (c.fullConversationHeadersOnly ?? []).length;
+}
+function isMeaningfulComposer(c) {
+  if (!c || typeof c !== "object") return false;
+  if (typeof c.composerId !== "string") return false;
+  return headerCount(c) > 0 && (c.text !== void 0 || c.name !== void 0);
+}
+function _conversationHeader(c, bubbleId) {
+  return (c.fullConversationHeadersOnly ?? []).find(
+    (h) => h.bubbleId === bubbleId
+  );
+}
+
+// src/ingest.ts
+import { randomUUID } from "crypto";
+import { hashJson } from "@meterbility/shared";
+import {
+  getRunBySessionId,
+  insertRun,
+  insertStep,
+  recordContextSnapshot,
+  setRunStatus,
+  updateRunTotals,
+  upsertAgent,
+  upsertProjectByCwd
+} from "@meterbility/collector";
+var SOURCE_RUNTIME = "cursor";
+async function ingestCursorGlobal(store, opts = {}) {
+  const { dbPath } = await import("./discover-OXMJMPOW.js").then((m) => ({
+    dbPath: opts.dbPath ?? m.defaultGlobalDbPath()
+  }));
+  let cursor;
+  try {
+    cursor = new CursorDb(dbPath);
+  } catch (err) {
+    return {
+      composers_seen: 0,
+      composers_ingested: 0,
+      steps_added: 0,
+      status: "no_db",
+      reason: `cannot open ${dbPath}: ${err.message}`
+    };
+  }
+  try {
+    if (!cursor.hasCursorDiskKV()) {
+      return {
+        composers_seen: 0,
+        composers_ingested: 0,
+        steps_added: 0,
+        status: "no_db",
+        reason: "cursorDiskKV table missing \u2014 schema may have changed"
+      };
+    }
+    let composers = cursor.listComposers().filter(isMeaningfulComposer);
+    if (opts.composerId) {
+      composers = composers.filter((c) => c.composerId === opts.composerId);
+    }
+    if (opts.sinceMs !== void 0) {
+      composers = composers.filter(
+        (c) => (c.lastUpdatedAt ?? c.createdAt ?? 0) >= opts.sinceMs
+      );
+    }
+    composers.sort(
+      (a, b) => (b.lastUpdatedAt ?? b.createdAt ?? 0) - (a.lastUpdatedAt ?? a.createdAt ?? 0)
+    );
+    if (opts.limit) composers = composers.slice(0, opts.limit);
+    if (composers.length === 0) {
+      return {
+        composers_seen: 0,
+        composers_ingested: 0,
+        steps_added: 0,
+        status: "no_composers",
+        reason: "no Cursor composers matched the filter"
+      };
+    }
+    const cwd = opts.cwd ?? "(cursor)";
+    const project = upsertProjectByCwd(store, cwd, "cursor");
+    const agent = upsertAgent(store, project.project_id, "cursor");
+    let composersIngested = 0;
+    let stepsAdded = 0;
+    for (const comp of composers) {
+      const result = await ingestOneComposer(store, cursor, comp, {
+        projectId: project.project_id,
+        agentId: agent.agent_id,
+        cwd
+      });
+      composersIngested += 1;
+      stepsAdded += result.steps_added;
+    }
+    return {
+      composers_seen: composers.length,
+      composers_ingested: composersIngested,
+      steps_added: stepsAdded,
+      status: "ok"
+    };
+  } finally {
+    cursor.close();
+  }
+}
+async function ingestOneComposer(store, cursor, comp, args) {
+  const sessionId = comp.composerId;
+  const existing = getRunBySessionId(store, sessionId);
+  let runId;
+  if (existing) {
+    runId = existing.run_id;
+  } else {
+    runId = `run_${randomUUID()}`;
+    const run = {
+      run_id: runId,
+      agent_id: args.agentId,
+      project_id: args.projectId,
+      source_session_id: sessionId,
+      source_runtime: SOURCE_RUNTIME,
+      title: comp.name ?? comp.subtitle,
+      status: composerStatus(comp),
+      started_at: epochMsToIso(comp.createdAt) ?? (/* @__PURE__ */ new Date()).toISOString(),
+      ended_at: epochMsToIso(comp.lastUpdatedAt),
+      git_branch: void 0,
+      cwd: args.cwd,
+      tokens_total_input: 0,
+      tokens_total_output: 0,
+      tokens_total_cached: 0,
+      cost_cents: 0,
+      step_count: 0,
+      tags: ["cost:approx", "cursor", `mode:${comp.unifiedMode ?? "?"}`]
+    };
+    insertRun(store, run);
+  }
+  const history = [];
+  let sequence = existing ? existing.step_count ?? 0 : 0;
+  let prevStepId;
+  let stepsAdded = 0;
+  for (const bubble of cursor.iterBubbles(comp)) {
+    const text = bubbleText(bubble);
+    if (isUserBubble(bubble)) {
+      const ref = await store.blobs.putString(text);
+      history.push({ role: "user", content_ref: ref });
+      const components = await snapshotComponents(history);
+      const snapshot = {
+        id: hashJson(components),
+        components
+      };
+      const blobRef = await store.blobs.putJson(snapshot);
+      recordContextSnapshot(store, snapshot.id, blobRef, snapshot.components.length);
+      const decisionRef = await store.blobs.putString(text);
+      const stepId = `stp_${randomUUID()}`;
+      const step = {
+        step_id: stepId,
+        run_id: runId,
+        parent_step_id: prevStepId,
+        sequence,
+        timestamp: bubble.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        model: "user",
+        context_snapshot_id: snapshot.id,
+        decision_ref: decisionRef,
+        action: { kind: "message", text },
+        outcome: { status: "ok" },
+        tokens: { input: 0, output: 0, cached_read: 0, cache_creation: 0 },
+        latency_ms: 0,
+        cost_cents: 0,
+        tags: ["cursor", "user-turn"],
+        status: "ok"
+      };
+      insertStep(store, step);
+      prevStepId = stepId;
+      sequence += 1;
+      stepsAdded += 1;
+      continue;
+    }
+    if (isAssistantBubble(bubble)) {
+      const components = await snapshotComponents(history);
+      const snapshot = {
+        id: hashJson(components),
+        components
+      };
+      const blobRef = await store.blobs.putJson(snapshot);
+      recordContextSnapshot(store, snapshot.id, blobRef, snapshot.components.length);
+      const action = bubbleToAction(bubble, text);
+      const outcome = await bubbleToOutcome(store, bubble);
+      const decisionRef = await store.blobs.putJson({
+        text,
+        thinking: bubble.allThinkingBlocks,
+        codeBlocks: bubble.codeBlocks,
+        toolFormer: bubble.toolFormerData
+      });
+      const tokens = {
+        input: bubble.tokenCount?.inputTokens ?? 0,
+        output: bubble.tokenCount?.outputTokens ?? 0,
+        cached_read: 0,
+        cache_creation: 0
+      };
+      const stepId = `stp_${randomUUID()}`;
+      const step = {
+        step_id: stepId,
+        run_id: runId,
+        parent_step_id: prevStepId,
+        sequence,
+        timestamp: bubble.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        model: modelFromComposer(comp) ?? "cursor",
+        context_snapshot_id: snapshot.id,
+        decision_ref: decisionRef,
+        action,
+        outcome,
+        tokens,
+        latency_ms: 0,
+        cost_cents: 0,
+        tags: ["cost:approx", "cursor"],
+        status: outcome.status === "error" ? "error" : outcome.status === "pending" ? "in_progress" : "ok"
+      };
+      insertStep(store, step);
+      prevStepId = stepId;
+      sequence += 1;
+      stepsAdded += 1;
+      const assistantText = text || (bubble.toolFormerData?.name ? `[${bubble.toolFormerData.name}]` : "");
+      const aref = await store.blobs.putString(assistantText);
+      history.push({ role: "assistant", content_ref: aref });
+      continue;
+    }
+  }
+  setRunStatus(store, runId, composerStatus(comp), epochMsToIso(comp.lastUpdatedAt));
+  updateRunTotals(store, runId);
+  return { steps_added: stepsAdded };
+}
+async function snapshotComponents(history) {
+  if (history.length === 0) return [];
+  return [{ type: "conversation_history", messages: [...history] }];
+}
+function bubbleToAction(bubble, text) {
+  const tf = bubble.toolFormerData;
+  if (tf?.name) {
+    return {
+      kind: "tool_call",
+      tool_name: tf.name,
+      tool_use_id: tf.toolCallId ?? tf.modelCallId,
+      tool_input: parseMaybeJson(tf.params) ?? parseMaybeJson(tf.rawArgs)
+    };
+  }
+  if (text && text.trim().length > 0) {
+    return { kind: "message", text };
+  }
+  if (bubble.allThinkingBlocks && bubble.allThinkingBlocks.length > 0) {
+    return { kind: "thinking_only" };
+  }
+  return { kind: "none" };
+}
+async function bubbleToOutcome(store, bubble) {
+  const tf = bubble.toolFormerData;
+  if (!tf) return { status: "ok" };
+  if (tf.status === "errored") {
+    const ref = tf.result ? await store.blobs.putJson(tf.result) : void 0;
+    return {
+      status: "error",
+      is_error: true,
+      tool_result_ref: ref,
+      summary: typeof tf.result === "string" ? tf.result.slice(0, 200) : "tool errored"
+    };
+  }
+  if (tf.status === "completed" && tf.result !== void 0) {
+    const ref = await store.blobs.putJson(tf.result);
+    return {
+      status: "ok",
+      tool_result_ref: ref,
+      summary: typeof tf.result === "string" ? tf.result.split("\n")[0]?.slice(0, 200) : void 0
+    };
+  }
+  if (tf.status === "pending") return { status: "pending" };
+  return { status: "ok" };
+}
+function composerStatus(c) {
+  switch (c.status) {
+    case "completed":
+      return "ok";
+    case "error":
+    case "errored":
+      return "error";
+    case "abandoned":
+      return "abandoned";
+    default:
+      return "in_progress";
+  }
+}
+function modelFromComposer(c) {
+  const cfg = c.modelConfig;
+  if (cfg && typeof cfg === "object") {
+    const m = cfg.model ?? cfg.name;
+    if (typeof m === "string") return m;
+  }
+  return void 0;
+}
+function parseMaybeJson(v) {
+  if (typeof v !== "string") return v;
+  try {
+    return JSON.parse(v);
+  } catch {
+    return v;
+  }
+}
+function epochMsToIso(ms) {
+  if (ms === void 0 || !Number.isFinite(ms) || ms <= 0) return void 0;
+  return new Date(ms).toISOString();
+}
+export {
+  CursorDb,
+  _conversationHeader,
+  bubbleText,
+  cursorPaths,
+  defaultGlobalDbPath,
+  discoverCursorWorkspaces,
+  headerCount,
+  ingestCursorGlobal,
+  isAssistantBubble,
+  isMeaningfulComposer,
+  isUserBubble,
+  readWorkspaceCwd
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@meterbility/cursor-adapter",
+  "version": "0.3.1",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@meterbility/shared": "^0.3.0",
+    "@meterbility/spec": "^0.3.0",
+    "@meterbility/collector": "^0.3.0",
+    "better-sqlite3": "^11.3.0"
+  },
+  "description": "Cursor composer capture adapter for Meterbility",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HoneycombHairDevelopers/Meterbility.git",
+    "directory": "adapters/cursor"
+  },
+  "homepage": "https://github.com/HoneycombHairDevelopers/Meterbility#readme",
+  "bugs": {
+    "url": "https://github.com/HoneycombHairDevelopers/Meterbility/issues"
+  },
+  "engines": {
+    "node": ">=20.6"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "types": "dist/index.d.ts",
+  "tsup": {
+    "entry": [
+      "src/index.ts"
+    ],
+    "format": [
+      "esm"
+    ],
+    "dts": true,
+    "clean": true
+  },
+  "scripts": {
+    "build": "tsup"
+  }
+}