devpulse-ai 0.1.0

package/README.md

@@ -0,0 +1,77 @@
+# DevPulse CLI
+
+Sync local AI coding tool sessions to your DevPulse team dashboard.
+
+## Supported tools
+
+| Tool | Source | Token usage |
+| --- | --- | --- |
+| **Claude Code** | `~/.claude/projects/**/*.jsonl` | ✅ full |
+| **Codex** | `~/.codex/sessions/**/rollout-*.jsonl` | ✅ full |
+| **OpenClaw** | `~/.openclaw/agents/*/sessions/*.jsonl` | ✅ full |
+| **Cursor** | `ai-code-tracking.db` + `state.vscdb` + `agent-transcripts` | ⚠️ tokens not available locally |
+
+Each machine syncs whatever tools it has; absent tools are skipped automatically.
+
+## Install
+
+Requires Node.js **22+**.
+
+```bash
+npm install -g devpulse-ai
+```
+
+## Usage
+
+```bash
+# 1. Log in (opens your browser to authorize this machine)
+devpulse login
+
+# 2. Scan every detected tool and upload new/changed sessions
+devpulse sync
+
+# 3. Inspect detected tools and pending sessions without uploading
+devpulse status
+
+# 4. (Optional) Auto-sync on a schedule — every 6 hours or daily at 9am
+devpulse schedule install --every 6
+devpulse schedule install --daily --at 09:00
+```
+
+## Commands
+
+| Command | Description |
+| --- | --- |
+| `login` | Opens your browser to authorize the CLI (like Claude Code). `--token <t>` or `--no-browser` for manual paste. `--api-url <url>` for self-hosted dashboards. |
+| `sync` | Parse local sessions and upload metadata. `--dry-run`, `--force`, `--dir <path>` (Claude Code), `--tool <name>` (claude-code/openclaw/cursor), `--limit <n>`. |
+| `status` | Show login state, detected tools, synced count, and pending changes. `--tool <name>`, `--dir <path>`. |
+| `schedule install` | Install background auto-sync via macOS launchd or Linux cron. `--every <hours>` (1–24) or `--daily [--at HH:MM]`. |
+| `schedule status` | Show the installed schedule and log file path. |
+| `schedule remove` | Uninstall background auto-sync. |
+
+## What it reads & uploads
+
+For each session the CLI extracts **lightweight metadata only**:
+
+- session id (used to dedupe), tool, model
+- start/end time, message count
+- input/output/cache token usage (where the tool exposes it)
+- project name + a hashed project path (the raw path is never uploaded)
+- a short rule-based summary (derived locally — Cursor uses composer title, first user query, or edited files)
+
+**No transcript content, code, or prompts are uploaded** — only derived metadata and cleaned `summaryNotes` for server-side LLM summarization (when `OPENROUTER_API_KEY` is set on the dashboard).
+
+## Requirements
+
+Node.js **22+** (the Cursor adapter uses the built-in `node:sqlite`; on older Node the Cursor tool is simply skipped).
+
+## Config
+
+Stored in `~/.devpulse/`:
+
+- `config.json` — dashboard URL + token (chmod 600)
+- `state.json` — per-session fingerprints for dedupe
+- `schedule.json` — automatic sync schedule (when installed)
+- `schedule.log` — stdout/stderr from scheduled `devpulse sync` runs
+
+Set `DEVPULSE_API_URL=http://localhost:3000` (or `devpulse login --api-url http://localhost:3000`) when developing against a local Next.js server. By default the CLI points at the hosted dashboard at `https://7aj5nkyd.insforge.site`.

package/dist/adapters/claude-code.js

@@ -0,0 +1,36 @@
+import { existsSync } from "node:fs";
+import { claudeProjectsDir, listSessionFiles, fingerprintFile, parseSessionFile, } from "../parser/claude-code.js";
+const TOOL = "claude-code";
+export const claudeCodeAdapter = {
+    tool: TOOL,
+    label: "Claude Code",
+    available(opts) {
+        return existsSync(opts?.dir ?? claudeProjectsDir());
+    },
+    discover(opts) {
+        const dir = opts?.dir ?? claudeProjectsDir();
+        return listSessionFiles(dir).map((file) => ({
+            // Change detection is per-file so each transcript is tracked independently.
+            stateKey: `${TOOL}:${file}`,
+            fingerprint: safeFingerprint(file),
+            load: () => {
+                const parsed = parseSessionFile(file);
+                if (!parsed)
+                    return null;
+                // Namespace the upload id by tool. Two transcripts that share a session
+                // uuid collapse server-side into one row.
+                parsed.metadata.externalId = `${TOOL}:${parsed.metadata.externalId}`;
+                parsed.metadata.tool = TOOL;
+                return parsed.metadata;
+            },
+        }));
+    },
+};
+function safeFingerprint(file) {
+    try {
+        return fingerprintFile(file);
+    }
+    catch {
+        return "";
+    }
+}

package/dist/adapters/codex.js

@@ -0,0 +1,224 @@
+import { homedir } from "node:os";
+import { join, basename } from "node:path";
+import { createHash } from "node:crypto";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { buildSessionSummary } from "../summary.js";
+import { buildSummaryNotes, cleanUserText } from "../session-notes.js";
+const TOOL = "codex";
+function codexHome() {
+    return process.env.CODEX_HOME?.replace(/\/$/, "") || join(homedir(), ".codex");
+}
+function loadSessionIndex() {
+    const path = join(codexHome(), "session_index.jsonl");
+    const map = new Map();
+    if (!existsSync(path))
+        return map;
+    for (const line of readFileSync(path, "utf8").split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const row = JSON.parse(trimmed);
+            if (row.id)
+                map.set(row.id, row);
+        }
+        catch {
+            /* skip malformed index line */
+        }
+    }
+    return map;
+}
+/** Active + archived Codex rollout transcripts. */
+function listCodexSessionFiles() {
+    const roots = [join(codexHome(), "sessions"), join(codexHome(), "archived_sessions")];
+    const out = [];
+    for (const root of roots) {
+        if (!existsSync(root))
+            continue;
+        collectRollouts(root, out);
+    }
+    return out;
+}
+function collectRollouts(dir, out) {
+    for (const ent of readdirSync(dir, { withFileTypes: true })) {
+        const p = join(dir, ent.name);
+        if (ent.isDirectory())
+            collectRollouts(p, out);
+        else if (ent.isFile() && ent.name.startsWith("rollout-") && ent.name.endsWith(".jsonl")) {
+            out.push(p);
+        }
+    }
+}
+function sessionIdFromFile(filePath) {
+    const m = filePath.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i);
+    return m?.[1] ?? null;
+}
+function extractMessageText(payload) {
+    if (typeof payload.text === "string")
+        return payload.text;
+    const content = payload.content;
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => {
+            if (typeof part === "string")
+                return part;
+            if (part && typeof part === "object") {
+                const p = part;
+                return p.text ?? p.input_text ?? "";
+            }
+            return "";
+        })
+            .join("\n")
+            .trim();
+    }
+    return null;
+}
+function isNoiseUserText(text) {
+    const t = text.trim();
+    if (!t)
+        return true;
+    if (t.startsWith("<permissions instructions>"))
+        return true;
+    if (t.startsWith("Response MUST end with a remark-directive"))
+        return true;
+    if (t.startsWith("<skills_instructions>"))
+        return true;
+    if (t.startsWith("<plugins_instructions>"))
+        return true;
+    if (t.startsWith("<app-context>"))
+        return true;
+    if (t.startsWith("The user interrupted the previous turn"))
+        return true;
+    return false;
+}
+function parseCodexSession(filePath, index) {
+    const lines = readFileSync(filePath, "utf8").split("\n");
+    let sessionId = sessionIdFromFile(filePath);
+    let cwd = null;
+    let model = null;
+    const userMessages = [];
+    const seenUserMessages = new Set();
+    let messageCount = 0;
+    const timestamps = [];
+    let lastTokenUsage = null;
+    function pushUserMessage(raw) {
+        const cleaned = raw ? cleanUserText(raw) : null;
+        if (!cleaned || isNoiseUserText(cleaned) || seenUserMessages.has(cleaned))
+            return;
+        seenUserMessages.add(cleaned);
+        userMessages.push(cleaned);
+    }
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let row;
+        try {
+            row = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (row.timestamp) {
+            const t = Date.parse(row.timestamp);
+            if (!Number.isNaN(t))
+                timestamps.push(t);
+        }
+        if (row.type === "session_meta" && row.payload) {
+            const p = row.payload;
+            sessionId = p.id ?? sessionId;
+            cwd = p.cwd ?? cwd;
+        }
+        if (row.type === "turn_context" && row.payload) {
+            const p = row.payload;
+            if (p.model)
+                model = p.model;
+        }
+        if (row.type === "event_msg" && row.payload) {
+            const p = row.payload;
+            if (p.type === "user_message" && typeof p.message === "string") {
+                pushUserMessage(p.message);
+            }
+            if (p.type === "token_count") {
+                lastTokenUsage = p.info?.total_token_usage ?? p.info?.last_token_usage ?? lastTokenUsage;
+            }
+        }
+        if (row.type === "response_item" && row.payload) {
+            const p = row.payload;
+            if (p.type === "message") {
+                messageCount++;
+                if (p.role === "user") {
+                    pushUserMessage(extractMessageText(p));
+                }
+            }
+        }
+    }
+    if (messageCount === 0 && timestamps.length === 0 && !lastTokenUsage)
+        return null;
+    const rawId = sessionId ?? basename(filePath, ".jsonl");
+    const threadName = rawId ? index.get(rawId)?.thread_name ?? null : null;
+    const projectName = cwd ? basename(cwd) : null;
+    const projectPathHash = cwd ? createHash("sha256").update(cwd).digest("hex").slice(0, 32) : null;
+    const nonAutomation = userMessages.filter((m) => !/^Automation:/i.test(m));
+    const firstUserText = nonAutomation[0] ??
+        (threadName && !/^ClawMatrix scheduled run/i.test(threadName) ? threadName : null) ??
+        userMessages[0] ??
+        threadName;
+    const summaryNotes = buildSummaryNotes({
+        tool: TOOL,
+        projectName,
+        title: threadName,
+        userMessages: nonAutomation.length ? nonAutomation : userMessages,
+    });
+    const inputTokens = lastTokenUsage?.input_tokens ?? 0;
+    const outputTokens = lastTokenUsage?.output_tokens ?? 0;
+    const cacheReadTokens = lastTokenUsage?.cached_input_tokens ?? lastTokenUsage?.cache_read_input_tokens ?? 0;
+    const cacheCreationTokens = lastTokenUsage?.cache_creation_input_tokens ?? 0;
+    return {
+        externalId: `${TOOL}:${rawId}`,
+        tool: TOOL,
+        model,
+        projectPathHash,
+        projectName,
+        summary: buildSessionSummary({
+            firstUserText,
+            explicitSummary: threadName,
+            projectName,
+            messageCount,
+        }),
+        summaryNotes,
+        messageCount,
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheCreationTokens,
+        startedAt: timestamps.length ? new Date(Math.min(...timestamps)).toISOString() : null,
+        endedAt: timestamps.length ? new Date(Math.max(...timestamps)).toISOString() : null,
+    };
+}
+export const codexAdapter = {
+    tool: TOOL,
+    label: "Codex",
+    available() {
+        return existsSync(join(codexHome(), "sessions")) || existsSync(join(codexHome(), "archived_sessions"));
+    },
+    discover() {
+        const index = loadSessionIndex();
+        return listCodexSessionFiles().map((file) => ({
+            stateKey: `${TOOL}:${file}`,
+            fingerprint: safeFingerprint(file),
+            load: () => parseCodexSession(file, index),
+        }));
+    },
+};
+function safeFingerprint(file) {
+    try {
+        const st = statSync(file);
+        return `${Math.round(st.mtimeMs)}:${st.size}`;
+    }
+    catch {
+        return "";
+    }
+}

package/dist/adapters/cursor-sources.js

@@ -0,0 +1,201 @@
+import { homedir, platform } from "node:os";
+import { join, basename } from "node:path";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { buildSessionSummary } from "../summary.js";
+import { buildSummaryNotes } from "../session-notes.js";
+/** Bump when summary derivation changes so existing sessions re-sync once. */
+export const CURSOR_SUMMARY_VERSION = "v3";
+export function cursorHome() {
+    return process.env.CURSOR_HOME ?? join(homedir(), ".cursor");
+}
+export function globalStateDbPath() {
+    const home = homedir();
+    let path;
+    switch (platform()) {
+        case "darwin":
+            path = join(home, "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb");
+            break;
+        case "win32":
+            path = join(process.env.APPDATA ?? join(home, "AppData", "Roaming"), "Cursor", "User", "globalStorage", "state.vscdb");
+            break;
+        default:
+            path = join(home, ".config", "Cursor", "User", "globalStorage", "state.vscdb");
+    }
+    return existsSync(path) ? path : null;
+}
+/** Map composerId → agent-transcripts jsonl path (scan once per sync). */
+export function indexAgentTranscripts() {
+    const map = new Map();
+    const root = join(cursorHome(), "projects");
+    if (!existsSync(root))
+        return map;
+    for (const proj of readdirSync(root)) {
+        const dir = join(root, proj, "agent-transcripts");
+        if (!existsSync(dir))
+            continue;
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            if (entry.isDirectory()) {
+                const convId = entry.name;
+                for (const file of readdirSync(join(dir, convId))) {
+                    if (file.endsWith(".jsonl")) {
+                        map.set(convId, join(dir, convId, file));
+                        break;
+                    }
+                }
+            }
+            else if (entry.name.endsWith(".jsonl")) {
+                map.set(entry.name.replace(/\.jsonl$/, ""), join(dir, entry.name));
+            }
+        }
+    }
+    return map;
+}
+function stripTags(text) {
+    return text
+        .replace(/<user_query>\s*/g, "")
+        .replace(/<\/user_query>/g, "")
+        .replace(/<[^>]+>/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function userMessagesFromTranscript(filePath, limit = 12) {
+    const out = [];
+    try {
+        const lines = readFileSync(filePath, "utf8").trim().split("\n");
+        for (const line of lines) {
+            if (!line.trim() || out.length >= limit)
+                break;
+            const o = JSON.parse(line);
+            if (o.role !== "user")
+                continue;
+            const text = (o.message?.content ?? [])
+                .filter((c) => c.type === "text" && c.text)
+                .map((c) => c.text)
+                .join("\n");
+            const cleaned = stripTags(text);
+            if (cleaned)
+                out.push(cleaned);
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return out;
+}
+export function relativeFilePaths(files) {
+    return [...new Set(files.map((f) => {
+            const parts = f.split("/");
+            const idx = parts.findIndex((p) => p === "src" || p === "cli");
+            if (idx > 0)
+                return parts.slice(idx - 1).join("/");
+            return basename(f);
+        }))];
+}
+export function composerTitleFromState(db, conversationId) {
+    try {
+        const row = db.prepare("SELECT value FROM cursorDiskKV WHERE key = ?").all(`composerData:${conversationId}`)[0];
+        if (!row?.value)
+            return null;
+        const data = JSON.parse(String(row.value));
+        const title = data.name ?? data.title ?? null;
+        return title?.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function firstUserFromState(db, conversationId) {
+    try {
+        const rows = db
+            .prepare("SELECT value FROM cursorDiskKV WHERE key LIKE ? ORDER BY key LIMIT 40")
+            .all(`bubbleId:${conversationId}:%`);
+        for (const row of rows) {
+            if (!row?.value)
+                continue;
+            const v = JSON.parse(String(row.value));
+            if (v.type !== 1)
+                continue;
+            const cleaned = stripTags(String(v.text ?? ""));
+            if (cleaned)
+                return cleaned;
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return null;
+}
+export function guessProjectName(files) {
+    const counts = new Map();
+    for (const file of files) {
+        const parts = file.split("/");
+        for (let i = parts.length - 2; i >= 0; i--) {
+            const name = parts[i];
+            if (!name || ["src", "lib", "cli", "app", "components", "node_modules", "dist"].includes(name))
+                continue;
+            counts.set(name, (counts.get(name) ?? 0) + 1);
+            break;
+        }
+    }
+    const top = [...counts.entries()].sort((a, b) => b[1] - a[1])[0];
+    return top?.[0] ?? null;
+}
+function buildFileSummary(files) {
+    const rel = files.map((f) => {
+        const parts = f.split("/");
+        const idx = parts.findIndex((p) => p === "src" || p === "cli");
+        if (idx > 0)
+            return parts.slice(idx - 1).join("/");
+        return basename(f);
+    });
+    const unique = [...new Set(rel)];
+    const head = unique.slice(0, 4).join(", ");
+    return `Edited ${unique.length} file${unique.length === 1 ? "" : "s"}: ${head}${unique.length > 4 ? ", …" : ""}`;
+}
+/**
+ * Resolve a human-readable session summary without uploading transcript content.
+ * Priority: vscdb title → tracking title → transcript user → vscdb user → files → generic.
+ */
+export function buildCursorSummary(input) {
+    const { trackingTitle, files, messageCount, stateDb, transcriptPath } = input;
+    const projectName = guessProjectName(files);
+    const base = { projectName, messageCount };
+    const relFiles = relativeFilePaths(files);
+    let composerTitle = null;
+    if (stateDb)
+        composerTitle = composerTitleFromState(stateDb, input.conversationId);
+    const userMessages = transcriptPath ? userMessagesFromTranscript(transcriptPath) : [];
+    if (userMessages.length === 0 && stateDb) {
+        const first = firstUserFromState(stateDb, input.conversationId);
+        if (first)
+            userMessages.push(first);
+    }
+    const summaryNotes = buildSummaryNotes({
+        tool: "cursor",
+        projectName,
+        title: composerTitle ?? trackingTitle,
+        userMessages,
+        files: relFiles,
+    });
+    if (stateDb && composerTitle) {
+        const s = buildSessionSummary({ ...base, explicitSummary: composerTitle, firstUserText: null });
+        if (s)
+            return { summary: s, summaryNotes };
+    }
+    if (trackingTitle?.trim()) {
+        const s = buildSessionSummary({ ...base, explicitSummary: trackingTitle, firstUserText: null });
+        if (s)
+            return { summary: s, summaryNotes };
+    }
+    if (userMessages[0]) {
+        const s = buildSessionSummary({ ...base, explicitSummary: null, firstUserText: userMessages[0] });
+        if (s)
+            return { summary: s, summaryNotes };
+    }
+    if (files.length > 0)
+        return { summary: buildFileSummary(files), summaryNotes };
+    return {
+        summary: `Cursor session — ${messageCount} AI request${messageCount === 1 ? "" : "s"}.`,
+        summaryNotes,
+    };
+}

package/dist/adapters/cursor.js

@@ -0,0 +1,157 @@
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { buildCursorSummary, cursorHome, CURSOR_SUMMARY_VERSION, globalStateDbPath, guessProjectName, indexAgentTranscripts, } from "./cursor-sources.js";
+const TOOL = "cursor";
+const require = createRequire(import.meta.url);
+function cursorDbPath() {
+    return join(cursorHome(), "ai-tracking", "ai-code-tracking.db");
+}
+function loadSqlite() {
+    try {
+        return require("node:sqlite");
+    }
+    catch {
+        return null;
+    }
+}
+function mostFrequent(values) {
+    if (values.length === 0)
+        return null;
+    const counts = new Map();
+    for (const v of values)
+        counts.set(v, (counts.get(v) ?? 0) + 1);
+    return [...counts.entries()].sort((a, b) => b[1] - a[1])[0][0];
+}
+/**
+ * Cursor session metadata from local stores:
+ * - ai-code-tracking.db — files, models, timestamps (no prompts)
+ * - state.vscdb — composer titles + user bubble text
+ * - agent-transcripts/*.jsonl — first user query per session
+ *
+ * Token usage is not available locally (Cursor API only).
+ */
+function buildCursorSessions() {
+    const sqlite = loadSqlite();
+    const dbPath = cursorDbPath();
+    if (!sqlite || !existsSync(dbPath))
+        return [];
+    let db;
+    try {
+        db = new sqlite.DatabaseSync(dbPath, { readOnly: true });
+    }
+    catch {
+        return [];
+    }
+    let stateDb = null;
+    const statePath = globalStateDbPath();
+    if (statePath && sqlite) {
+        try {
+            stateDb = new sqlite.DatabaseSync(statePath, { readOnly: true });
+        }
+        catch {
+            stateDb = null;
+        }
+    }
+    const transcripts = indexAgentTranscripts();
+    try {
+        const rows = db
+            .prepare(`SELECT conversationId, model, requestId, fileName, timestamp
+         FROM ai_code_hashes
+         WHERE source = 'composer' AND conversationId IS NOT NULL AND conversationId <> ''`)
+            .all();
+        const trackingTitles = new Map();
+        try {
+            for (const r of db
+                .prepare(`SELECT conversationId, title FROM conversation_summaries WHERE title IS NOT NULL`)
+                .all()) {
+                trackingTitles.set(r.conversationId, r.title);
+            }
+        }
+        catch {
+            /* optional table */
+        }
+        const byConv = new Map();
+        for (const r of rows) {
+            const a = byConv.get(r.conversationId) ??
+                { models: [], requestIds: new Set(), files: new Set(), hashes: 0, t0: null, t1: null };
+            a.hashes++;
+            if (r.model)
+                a.models.push(r.model);
+            if (r.requestId)
+                a.requestIds.add(r.requestId);
+            if (r.fileName)
+                a.files.add(r.fileName);
+            if (typeof r.timestamp === "number") {
+                a.t0 = a.t0 === null ? r.timestamp : Math.min(a.t0, r.timestamp);
+                a.t1 = a.t1 === null ? r.timestamp : Math.max(a.t1, r.timestamp);
+            }
+            byConv.set(r.conversationId, a);
+        }
+        const out = [];
+        for (const [convId, a] of byConv) {
+            const files = [...a.files];
+            const messageCount = a.requestIds.size || a.hashes;
+            const projectName = guessProjectName(files);
+            const { summary, summaryNotes } = buildCursorSummary({
+                conversationId: convId,
+                trackingTitle: trackingTitles.get(convId) ?? null,
+                files,
+                messageCount,
+                stateDb,
+                transcriptPath: transcripts.get(convId) ?? null,
+            });
+            out.push({
+                fingerprint: `${a.hashes}:${a.t1 ?? 0}:${CURSOR_SUMMARY_VERSION}`,
+                metadata: {
+                    externalId: `${TOOL}:${convId}`,
+                    tool: TOOL,
+                    model: mostFrequent(a.models),
+                    projectPathHash: null,
+                    projectName,
+                    summary,
+                    summaryNotes,
+                    messageCount,
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    cacheReadTokens: 0,
+                    cacheCreationTokens: 0,
+                    startedAt: a.t0 ? new Date(a.t0).toISOString() : null,
+                    endedAt: a.t1 ? new Date(a.t1).toISOString() : null,
+                },
+            });
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+    finally {
+        try {
+            db.close();
+        }
+        catch {
+            /* ignore */
+        }
+        try {
+            stateDb?.close();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+export const cursorAdapter = {
+    tool: TOOL,
+    label: "Cursor",
+    available() {
+        return loadSqlite() !== null && existsSync(cursorDbPath());
+    },
+    discover() {
+        return buildCursorSessions().map(({ metadata, fingerprint }) => ({
+            stateKey: metadata.externalId,
+            fingerprint,
+            load: () => metadata,
+        }));
+    },
+};