@agentoryhq/adapter-cursor 0.1.1

package/dist/align.d.ts

@@ -0,0 +1,7 @@
+import type { ApplyAlignOpts, ApplyAlignResult } from "@agentoryhq/runtime-contract";
+/**
+ * Write confirmed align patch to Cursor project files.
+ * Snapshots prior mcp.json under `.cursor/agentory-snapshots/`.
+ * All-or-nothing: on failure restores snapshot when possible.
+ */
+export declare function applyAlignPatch(opts: ApplyAlignOpts): ApplyAlignResult;

package/dist/align.js

@@ -0,0 +1,64 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Write confirmed align patch to Cursor project files.
+ * Snapshots prior mcp.json under `.cursor/agentory-snapshots/`.
+ * All-or-nothing: on failure restores snapshot when possible.
+ */
+export function applyAlignPatch(opts) {
+    const mcpPath = path.join(opts.projectRoot, ".cursor", "mcp.json");
+    const skillsPath = path.join(opts.projectRoot, ".cursor", "agentory-skills.json");
+    if (!opts.confirmed) {
+        return {
+            ok: false,
+            error: "refusing write: align not confirmed",
+            mcpPath,
+            skillsPath,
+        };
+    }
+    const cursorDir = path.join(opts.projectRoot, ".cursor");
+    fs.mkdirSync(cursorDir, { recursive: true });
+    let snapshotPath;
+    let priorMcp;
+    try {
+        if (fs.existsSync(mcpPath)) {
+            priorMcp = fs.readFileSync(mcpPath, "utf8");
+            const snapDir = path.join(cursorDir, "agentory-snapshots");
+            fs.mkdirSync(snapDir, { recursive: true });
+            snapshotPath = path.join(snapDir, `mcp-${Date.now()}.json`);
+            fs.writeFileSync(snapshotPath, priorMcp, "utf8");
+        }
+        const mcpServers = {};
+        for (const item of opts.patch.mcp) {
+            const command = item.command?.trim() || "echo";
+            const parts = command.split(/\s+/);
+            mcpServers[item.name] = {
+                command: parts[0] ?? "echo",
+                args: parts.length > 1 ? parts.slice(1) : undefined,
+            };
+        }
+        const mcpBody = JSON.stringify({ mcpServers }, null, 2);
+        const skillsBody = JSON.stringify({ skills: opts.patch.skills }, null, 2);
+        fs.writeFileSync(mcpPath, `${mcpBody}\n`, "utf8");
+        try {
+            fs.writeFileSync(skillsPath, `${skillsBody}\n`, "utf8");
+        }
+        catch (err) {
+            if (priorMcp !== undefined)
+                fs.writeFileSync(mcpPath, priorMcp, "utf8");
+            else if (fs.existsSync(mcpPath))
+                fs.unlinkSync(mcpPath);
+            throw err;
+        }
+        return { ok: true, mcpPath, skillsPath, snapshotPath };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+            mcpPath,
+            skillsPath,
+            snapshotPath,
+        };
+    }
+}

package/dist/asset-index.d.ts

@@ -0,0 +1,12 @@
+import type { AdapterContext, AssetIndexResult } from "@agentoryhq/runtime-contract";
+/** Map Cursor project dir slug → absolute folder path (best-effort). */
+export declare function buildCursorProjectPathMap(homeDir: string): Map<string, string>;
+/** Read only enough of the transcript to derive a short title — never return full body. */
+export declare function titleFromTranscriptJsonl(file: string): string;
+/**
+ * Cursor asset index (metadata only) — no Host fixtures.
+ * - Legacy: `.cursor/sessions/*.meta.json`
+ * - Native: ~/.cursor/projects/<slug>/agent-transcripts/<id>/<id>.jsonl
+ * - Rules / memory dirs (path + mtime only)
+ */
+export declare function indexCursorSessions(ctx: AdapterContext): AssetIndexResult;

package/dist/asset-index.js

@@ -0,0 +1,278 @@
+import fs from "node:fs";
+import path from "node:path";
+const TITLE_MAX = 80;
+function readJsonFile(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function mtimeIso(file) {
+    try {
+        return fs.statSync(file).mtime.toISOString();
+    }
+    catch {
+        return new Date(0).toISOString();
+    }
+}
+function slugifyAbsPath(abs) {
+    return abs.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\//g, "-");
+}
+/** Map Cursor project dir slug → absolute folder path (best-effort). */
+export function buildCursorProjectPathMap(homeDir) {
+    const map = new Map();
+    const add = (folderUri) => {
+        const raw = folderUri.startsWith("file://") ? folderUri.slice("file://".length) : folderUri;
+        if (!raw.startsWith("/"))
+            return;
+        map.set(slugifyAbsPath(raw), raw);
+    };
+    const storageJson = path.join(homeDir, "Library", "Application Support", "Cursor", "User", "globalStorage", "storage.json");
+    const storage = readJsonFile(storageJson);
+    if (storage && typeof storage === "object") {
+        const folders = storage
+            .backupWorkspaces?.folders;
+        if (Array.isArray(folders)) {
+            for (const f of folders) {
+                if (f?.folderUri)
+                    add(f.folderUri);
+            }
+        }
+    }
+    const wsRoot = path.join(homeDir, "Library", "Application Support", "Cursor", "User", "workspaceStorage");
+    try {
+        for (const name of fs.readdirSync(wsRoot)) {
+            const wj = readJsonFile(path.join(wsRoot, name, "workspace.json"));
+            if (wj && typeof wj === "object") {
+                const folder = wj.folder;
+                if (typeof folder === "string")
+                    add(folder);
+            }
+        }
+    }
+    catch {
+        /* no workspaceStorage */
+    }
+    return map;
+}
+function extractTextBlob(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const c of content) {
+            if (typeof c === "string")
+                parts.push(c);
+            else if (c && typeof c === "object" && typeof c.text === "string") {
+                parts.push(c.text);
+            }
+        }
+        return parts.join(" ");
+    }
+    if (content && typeof content === "object" && typeof content.text === "string") {
+        return content.text;
+    }
+    return "";
+}
+/** Read only enough of the transcript to derive a short title — never return full body. */
+export function titleFromTranscriptJsonl(file) {
+    try {
+        const fd = fs.openSync(file, "r");
+        try {
+            const buf = Buffer.alloc(16 * 1024);
+            const n = fs.readSync(fd, buf, 0, buf.length, 0);
+            const chunk = buf.slice(0, n).toString("utf8");
+            for (const line of chunk.split("\n")) {
+                if (!line.trim())
+                    continue;
+                let o;
+                try {
+                    o = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (!o || typeof o !== "object")
+                    continue;
+                const row = o;
+                if (row.role !== "user")
+                    continue;
+                const msg = row.message;
+                let text = "";
+                if (typeof msg === "string")
+                    text = msg;
+                else if (msg && typeof msg === "object") {
+                    text = extractTextBlob(msg.content);
+                }
+                text = text
+                    .replace(/<timestamp>[\s\S]*?<\/timestamp>/gi, " ")
+                    .replace(/<\/?user_query>/gi, " ")
+                    .replace(/\s+/g, " ")
+                    .trim();
+                if (!text)
+                    continue;
+                return text.length > TITLE_MAX ? `${text.slice(0, TITLE_MAX)}…` : text;
+            }
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return "";
+}
+function collectMetaSessions(cwd, home) {
+    const sessions = [];
+    const sessionDirs = [path.join(cwd, ".cursor", "sessions"), path.join(home, ".cursor", "sessions")];
+    for (const dir of sessionDirs) {
+        if (!fs.existsSync(dir))
+            continue;
+        for (const name of fs.readdirSync(dir)) {
+            if (!name.endsWith(".meta.json"))
+                continue;
+            const file = path.join(dir, name);
+            const raw = readJsonFile(file);
+            if (!raw || typeof raw !== "object")
+                continue;
+            const o = raw;
+            const displayName = typeof o.displayName === "string" && o.displayName.trim()
+                ? o.displayName.trim()
+                : name.replace(/\.meta\.json$/, "");
+            const updatedAt = typeof o.updatedAt === "string" ? o.updatedAt : mtimeIso(file);
+            const projectPath = typeof o.projectPath === "string" ? o.projectPath : cwd;
+            sessions.push({
+                sourceKey: `cursor-session:${file}`,
+                displayName,
+                projectPath,
+                updatedAt,
+            });
+        }
+    }
+    return sessions;
+}
+function collectNativeTranscripts(home) {
+    const sessions = [];
+    const projectsRoot = path.join(home, ".cursor", "projects");
+    if (!fs.existsSync(projectsRoot))
+        return sessions;
+    const pathMap = buildCursorProjectPathMap(home);
+    let projectNames = [];
+    try {
+        projectNames = fs.readdirSync(projectsRoot);
+    }
+    catch {
+        return sessions;
+    }
+    for (const slug of projectNames) {
+        const transcriptsRoot = path.join(projectsRoot, slug, "agent-transcripts");
+        if (!fs.existsSync(transcriptsRoot))
+            continue;
+        const projectPath = pathMap.get(slug) || slug;
+        let ids = [];
+        try {
+            ids = fs.readdirSync(transcriptsRoot);
+        }
+        catch {
+            continue;
+        }
+        for (const id of ids) {
+            const file = path.join(transcriptsRoot, id, `${id}.jsonl`);
+            if (!fs.existsSync(file))
+                continue;
+            try {
+                if (!fs.statSync(file).isFile())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            const title = titleFromTranscriptJsonl(file);
+            sessions.push({
+                sourceKey: `cursor-transcript:${file}`,
+                displayName: title || id.slice(0, 8),
+                projectPath,
+                updatedAt: mtimeIso(file),
+            });
+        }
+    }
+    return sessions;
+}
+function collectRulesAndMemory(cwd, home) {
+    const memories = [];
+    const ruleDirs = [path.join(cwd, ".cursor", "rules"), path.join(home, ".cursor", "rules")];
+    for (const dir of ruleDirs) {
+        if (!fs.existsSync(dir))
+            continue;
+        for (const name of fs.readdirSync(dir)) {
+            const file = path.join(dir, name);
+            try {
+                if (!fs.statSync(file).isFile())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            memories.push({
+                sourceKey: `cursor-rules:${file}`,
+                kind: "rules",
+                pathLabel: path.relative(cwd, file).replace(/\\/g, "/") || name,
+                projectPath: cwd,
+                updatedAt: mtimeIso(file),
+            });
+        }
+        if (memories.some((m) => m.kind === "rules"))
+            break;
+    }
+    const memoryDirs = [path.join(cwd, ".cursor", "memory"), path.join(home, ".cursor", "memory")];
+    for (const dir of memoryDirs) {
+        if (!fs.existsSync(dir))
+            continue;
+        for (const name of fs.readdirSync(dir)) {
+            const file = path.join(dir, name);
+            try {
+                if (!fs.statSync(file).isFile())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            memories.push({
+                sourceKey: `cursor-memory:${file}`,
+                kind: "memory",
+                pathLabel: path.relative(cwd, file).replace(/\\/g, "/") || name,
+                projectPath: cwd,
+                updatedAt: mtimeIso(file),
+            });
+        }
+        if (memories.some((m) => m.kind === "memory"))
+            break;
+    }
+    return memories;
+}
+/**
+ * Cursor asset index (metadata only) — no Host fixtures.
+ * - Legacy: `.cursor/sessions/*.meta.json`
+ * - Native: ~/.cursor/projects/<slug>/agent-transcripts/<id>/<id>.jsonl
+ * - Rules / memory dirs (path + mtime only)
+ */
+export function indexCursorSessions(ctx) {
+    const { cwd, homeDir: home } = ctx;
+    const sessions = [];
+    const seen = new Set();
+    const pushSession = (s) => {
+        if (seen.has(s.sourceKey))
+            return;
+        seen.add(s.sourceKey);
+        sessions.push(s);
+    };
+    for (const s of collectMetaSessions(cwd, home))
+        pushSession(s);
+    for (const s of collectNativeTranscripts(home))
+        pushSession(s);
+    sessions.sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : a.updatedAt > b.updatedAt ? -1 : 0));
+    return { sessions, memories: collectRulesAndMemory(cwd, home) };
+}

package/dist/discover.d.ts

@@ -0,0 +1,4 @@
+import type { AdapterContext } from "@agentoryhq/runtime-contract";
+import type { DiscoveredAgent } from "@agentoryhq/shared";
+export declare function detectCursor(ctx: AdapterContext): boolean;
+export declare function discoverCursorConfig(ctx: AdapterContext): DiscoveredAgent | null;

package/dist/discover.js

@@ -0,0 +1,87 @@
+import fs from "node:fs";
+import path from "node:path";
+function readJsonFile(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function mcpFromCursorConfig(raw) {
+    if (typeof raw !== "object" || raw === null)
+        return [];
+    const servers = raw.mcpServers;
+    if (typeof servers !== "object" || servers === null)
+        return [];
+    const out = [];
+    for (const [name, cfg] of Object.entries(servers)) {
+        if (!name)
+            continue;
+        let command;
+        if (typeof cfg === "object" && cfg !== null) {
+            const c = cfg;
+            if (typeof c.command === "string") {
+                const args = Array.isArray(c.args) ? c.args.map(String).join(" ") : "";
+                command = args ? `${c.command} ${args}` : c.command;
+            }
+        }
+        out.push({ name, command, status: "unknown" });
+    }
+    return out;
+}
+function skillsFromDir(dir) {
+    try {
+        return fs
+            .readdirSync(dir, { withFileTypes: true })
+            .filter((d) => d.isDirectory() || (d.isFile() && d.name.endsWith(".md")))
+            .map((d) => d.name.replace(/\.md$/, ""));
+    }
+    catch {
+        return [];
+    }
+}
+export function detectCursor(ctx) {
+    const cursorMcpCandidates = [
+        path.join(ctx.cwd, ".cursor", "mcp.json"),
+        path.join(ctx.homeDir, ".cursor", "mcp.json"),
+    ];
+    for (const file of cursorMcpCandidates) {
+        if (fs.existsSync(file))
+            return true;
+    }
+    return fs.existsSync(path.join(ctx.cwd, ".cursor"));
+}
+export function discoverCursorConfig(ctx) {
+    if (!detectCursor(ctx))
+        return null;
+    const cursorMcpCandidates = [
+        path.join(ctx.cwd, ".cursor", "mcp.json"),
+        path.join(ctx.homeDir, ".cursor", "mcp.json"),
+    ];
+    let cursorMcp = [];
+    for (const file of cursorMcpCandidates) {
+        if (!fs.existsSync(file))
+            continue;
+        cursorMcp = mcpFromCursorConfig(readJsonFile(file));
+        break;
+    }
+    const skillDirs = [
+        path.join(ctx.cwd, ".cursor", "skills"),
+        path.join(ctx.homeDir, ".cursor", "skills"),
+        path.join(ctx.cwd, ".cursor", "skills-cursor"),
+        path.join(ctx.homeDir, ".cursor", "skills-cursor"),
+    ];
+    const skillNames = new Set();
+    for (const d of skillDirs) {
+        for (const name of skillsFromDir(d))
+            skillNames.add(name);
+    }
+    return {
+        runtime: "cursor",
+        supported: true,
+        displayName: `Cursor · ${path.basename(ctx.cwd) || "workspace"}`,
+        mcp: cursorMcp,
+        skills: [...skillNames],
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import type { RuntimeAdapter } from "@agentoryhq/runtime-contract";
+export { applyAlignPatch } from "./align.js";
+export { buildCursorProjectPathMap, indexCursorSessions, titleFromTranscriptJsonl, } from "./asset-index.js";
+export { detectCursor, discoverCursorConfig } from "./discover.js";
+export { TRANSCRIPT_MESSAGE_MAX_CHARS, TRANSCRIPT_WINDOW_MESSAGES, captureTranscriptSnapshot, maskSecrets, transcriptFileForSourceKey, } from "./transcript.js";
+export declare const cursorAdapter: RuntimeAdapter;

package/dist/index.js

@@ -0,0 +1,29 @@
+import { ADAPTER_API_VERSION } from "@agentoryhq/runtime-contract";
+import { applyAlignPatch } from "./align.js";
+import { indexCursorSessions } from "./asset-index.js";
+import { detectCursor, discoverCursorConfig } from "./discover.js";
+import { captureTranscriptSnapshot, transcriptFileForSourceKey } from "./transcript.js";
+export { applyAlignPatch } from "./align.js";
+export { buildCursorProjectPathMap, indexCursorSessions, titleFromTranscriptJsonl, } from "./asset-index.js";
+export { detectCursor, discoverCursorConfig } from "./discover.js";
+export { TRANSCRIPT_MESSAGE_MAX_CHARS, TRANSCRIPT_WINDOW_MESSAGES, captureTranscriptSnapshot, maskSecrets, transcriptFileForSourceKey, } from "./transcript.js";
+export const cursorAdapter = {
+    manifest: {
+        runtime: "cursor",
+        adapterApi: ADAPTER_API_VERSION,
+        displayName: "Cursor",
+        capabilities: [
+            "detect",
+            "discoverConfig",
+            "applyAlign",
+            "indexSessions",
+            "readTranscript",
+        ],
+    },
+    detect: detectCursor,
+    discoverConfig: discoverCursorConfig,
+    applyAlign: applyAlignPatch,
+    indexSessions: indexCursorSessions,
+    transcriptFileForSourceKey,
+    captureTranscriptSnapshot,
+};

package/dist/transcript.d.ts

@@ -0,0 +1,29 @@
+import type { TranscriptSnapshot } from "@agentoryhq/shared";
+/**
+ * Node-side transcript capture for on-demand review (model B · S-tier).
+ * Whole pipeline is local: read JSONL → extract messages → mask secret-shaped
+ * strings → keep the near-end window. Only the masked, windowed snapshot ever
+ * leaves the machine; raw body is never logged (brief §5 AC-3/AC-9).
+ */
+/** 近端窗口上限（brief AC-4：具体值在此钉死） */
+export declare const TRANSCRIPT_WINDOW_MESSAGES = 40;
+/** 单条消息字符上限（同上） */
+export declare const TRANSCRIPT_MESSAGE_MAX_CHARS = 2000;
+/** Mask secret-shaped substrings BEFORE anything leaves the node (AC-3). */
+export declare function maskSecrets(text: string): string;
+/**
+ * Read the transcript at `file` and build a masked, windowed snapshot.
+ * Returns undefined when the file is missing/unreadable; an empty snapshot
+ * for a session with no extractable messages (brief AC-1 empty state).
+ */
+export declare function captureTranscriptSnapshot(file: string, now?: Date): TranscriptSnapshot | undefined;
+export type TranscriptFetchOpts = {
+    homeDir?: string;
+};
+/**
+ * Resolve a transcript file path for a session sourceKey
+ * (`cursor-transcript:<abs path>` as emitted by asset-index.ts).
+ * Only files under `~/.cursor/projects/` (or AGENTORY_CURSOR_ROOT override)
+ * qualify — no arbitrary path scanning (invariants §4).
+ */
+export declare function transcriptFileForSourceKey(sourceKey: string, homeDir?: string): string | undefined;

package/dist/transcript.js

@@ -0,0 +1,139 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+/**
+ * Node-side transcript capture for on-demand review (model B · S-tier).
+ * Whole pipeline is local: read JSONL → extract messages → mask secret-shaped
+ * strings → keep the near-end window. Only the masked, windowed snapshot ever
+ * leaves the machine; raw body is never logged (brief §5 AC-3/AC-9).
+ */
+/** 近端窗口上限（brief AC-4：具体值在此钉死） */
+export const TRANSCRIPT_WINDOW_MESSAGES = 40;
+/** 单条消息字符上限（同上） */
+export const TRANSCRIPT_MESSAGE_MAX_CHARS = 2000;
+const SECRET_PATTERNS = [
+    { re: /\bsk-[A-Za-z0-9_\-]{16,}/g, mask: "sk-••••••••" },
+    { re: /\bghp_[A-Za-z0-9]{20,}/g, mask: "ghp_••••••••" },
+    { re: /\bgho_[A-Za-z0-9]{20,}/g, mask: "gho_••••••••" },
+    { re: /\bgithub_pat_[A-Za-z0-9_]{20,}/g, mask: "github_pat_••••••••" },
+    { re: /\bxox[baprs]-[A-Za-z0-9\-]{16,}/g, mask: "xox•-••••••••" },
+    { re: /\bAKIA[0-9A-Z]{16}\b/g, mask: "AKIA••••••••" },
+    { re: /(?:password|passwd|pwd|secret|token|api[_-]?key)\s*[:=]\s*\S+/gi, mask: "password=••••••••" },
+    // 长随机密钥形态（hex/base64 ≥ 32 字符，独立成词）
+    { re: /\b[A-Za-z0-9+/]{40,}={0,2}\b/g, mask: "••••••••" },
+    { re: /\b[0-9a-f]{32,}\b/gi, mask: "••••••••" },
+];
+/** Mask secret-shaped substrings BEFORE anything leaves the node (AC-3). */
+export function maskSecrets(text) {
+    let out = text;
+    for (const { re, mask } of SECRET_PATTERNS) {
+        out = out.replace(re, mask);
+    }
+    return out;
+}
+function extractTextBlob(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const c of content) {
+            if (typeof c === "string")
+                parts.push(c);
+            else if (c && typeof c === "object" && typeof c.text === "string") {
+                parts.push(c.text);
+            }
+        }
+        return parts.join(" ");
+    }
+    if (content && typeof content === "object" && typeof content.text === "string") {
+        return content.text;
+    }
+    return "";
+}
+function cleanTimestampTag(text) {
+    return text
+        .replace(/<timestamp>[\s\S]*?<\/timestamp>/gi, " ")
+        .replace(/<\/?user_query>/gi, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+/**
+ * Read the transcript at `file` and build a masked, windowed snapshot.
+ * Returns undefined when the file is missing/unreadable; an empty snapshot
+ * for a session with no extractable messages (brief AC-1 empty state).
+ */
+export function captureTranscriptSnapshot(file, now = new Date()) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    const sourceKey = `cursor-transcript:${file}`;
+    const all = [];
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        let o;
+        try {
+            o = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!o || typeof o !== "object")
+            continue;
+        const row = o;
+        if (row.role !== "user" && row.role !== "assistant")
+            continue;
+        let text = "";
+        if (typeof row.message === "string")
+            text = row.message;
+        else if (row.message && typeof row.message === "object") {
+            text = extractTextBlob(row.message.content);
+        }
+        text = cleanTimestampTag(text);
+        if (!text)
+            continue;
+        if (text.length > TRANSCRIPT_MESSAGE_MAX_CHARS) {
+            text = `${text.slice(0, TRANSCRIPT_MESSAGE_MAX_CHARS)}…`;
+        }
+        const ts = typeof row.ts === "string" ? row.ts : "";
+        all.push({ role: row.role, ts, text });
+    }
+    const windowMessages = all.length > TRANSCRIPT_WINDOW_MESSAGES
+        ? all.slice(-TRANSCRIPT_WINDOW_MESSAGES)
+        : all;
+    const truncated = all.length > windowMessages.length;
+    return {
+        sourceKey,
+        messages: windowMessages.map((m) => ({ ...m, text: maskSecrets(m.text) })),
+        truncated,
+        windowTotal: truncated ? `${windowMessages.length} / ${all.length} 条` : undefined,
+        capturedAt: now.toISOString(),
+    };
+}
+/**
+ * Resolve a transcript file path for a session sourceKey
+ * (`cursor-transcript:<abs path>` as emitted by asset-index.ts).
+ * Only files under `~/.cursor/projects/` (or AGENTORY_CURSOR_ROOT override)
+ * qualify — no arbitrary path scanning (invariants §4).
+ */
+export function transcriptFileForSourceKey(sourceKey, homeDir) {
+    const prefix = "cursor-transcript:";
+    if (!sourceKey.startsWith(prefix))
+        return undefined;
+    const file = sourceKey.slice(prefix.length);
+    const home = homeDir ?? (process.env.AGENTORY_CURSOR_ROOT?.trim() || os.homedir());
+    const root = path.join(home, ".cursor", "projects");
+    try {
+        const rel = path.relative(root, file);
+        if (rel.startsWith("..") || path.isAbsolute(rel))
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    return file;
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@agentoryhq/adapter-cursor",
+  "version": "0.1.1",
+  "description": "Agentory RuntimeAdapter for Cursor",
+  "license": "Apache-2.0",
+  "type": "module",
+  "files": ["dist"],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@agentoryhq/runtime-contract": "*",
+    "@agentoryhq/shared": "*"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tunsuy/agentory-node.git",
+    "directory": "adapters/cursor"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}