pi-cursor-sdk 0.2.0 → 0.3.6

package/dist/cursor-cloud-reporting.js

@@ -0,0 +1,222 @@
+import { truncateCursorDisplayLine } from "./cursor-display-text.js";
+import { scrubSensitiveText } from "./cursor-sensitive-text.js";
+import { asRecord, getArray, getNumber, getRecord, getString } from "./cursor-record-utils.js";
+const DEFAULT_CURSOR_CLOUD_API_BASE_URL = "https://api.cursor.com";
+const CLOUD_REPORT_TIMEOUT_MS = 5000;
+const MAX_CLOUD_ID_DISPLAY_LENGTH = 160;
+const MAX_CLOUD_REPO_DISPLAY_LENGTH = 240;
+const MAX_CLOUD_BRANCH_DISPLAY_LENGTH = 160;
+const MAX_CLOUD_ARTIFACT_DISPLAY_LENGTH = 240;
+export const MAX_CLOUD_REPORT_BRANCHES = 5;
+export const MAX_CLOUD_REPORT_ARTIFACTS = 10;
+function withTimeout(promise, timeoutMs = CLOUD_REPORT_TIMEOUT_MS) {
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(undefined), timeoutMs);
+        timer.unref?.();
+    });
+    return Promise.race([promise.catch(() => undefined), timeout]).finally(() => {
+        if (timer)
+            clearTimeout(timer);
+    });
+}
+function fetchJsonWithAbortTimeout(fetchImpl, url, init, timeoutMs = CLOUD_REPORT_TIMEOUT_MS) {
+    const controller = new AbortController();
+    let timer;
+    const request = (async () => {
+        const response = await fetchImpl(url, { ...init, signal: controller.signal });
+        if (!response.ok)
+            return undefined;
+        return response.json();
+    })().catch(() => undefined);
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => {
+            controller.abort();
+            resolve(undefined);
+        }, timeoutMs);
+        timer.unref?.();
+    });
+    return Promise.race([request, timeout]).finally(() => {
+        if (timer)
+            clearTimeout(timer);
+    });
+}
+function readNonnegativeNumber(record, key) {
+    const value = getNumber(record, key);
+    return value !== undefined && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function readTokenUsage(value) {
+    const record = asRecord(value);
+    const inputTokens = readNonnegativeNumber(record, "inputTokens");
+    const outputTokens = readNonnegativeNumber(record, "outputTokens");
+    const cacheReadTokens = readNonnegativeNumber(record, "cacheReadTokens");
+    const cacheWriteTokens = readNonnegativeNumber(record, "cacheWriteTokens");
+    const totalTokens = readNonnegativeNumber(record, "totalTokens");
+    if (inputTokens === undefined ||
+        outputTokens === undefined ||
+        cacheReadTokens === undefined ||
+        cacheWriteTokens === undefined ||
+        totalTokens === undefined)
+        return undefined;
+    const reasoningTokens = readNonnegativeNumber(record, "reasoningTokens");
+    return {
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheWriteTokens,
+        totalTokens,
+        ...(reasoningTokens === undefined ? {} : { reasoningTokens }),
+    };
+}
+function readNonemptyString(record, key) {
+    const value = getString(record, key);
+    return value && truncateCursorDisplayLine(value) ? value : undefined;
+}
+function normalizeBranches(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => {
+        const record = asRecord(item);
+        const repoUrl = readNonemptyString(record, "repoUrl");
+        if (!repoUrl)
+            return [];
+        const branch = readNonemptyString(record, "branch");
+        const prUrl = readNonemptyString(record, "prUrl");
+        return branch || prUrl ? [{ repoUrl, ...(branch ? { branch } : {}), ...(prUrl ? { prUrl } : {}) }] : [];
+    });
+}
+function normalizeArtifacts(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value))
+        return undefined;
+    return value.flatMap((item) => {
+        const record = asRecord(item);
+        const path = readNonemptyString(record, "path");
+        const sizeBytes = readNonnegativeNumber(record, "sizeBytes");
+        const updatedAt = readNonemptyString(record, "updatedAt");
+        return path && sizeBytes !== undefined && updatedAt ? [{ path, sizeBytes, updatedAt }] : [];
+    });
+}
+function normalizeUsage(value) {
+    const record = asRecord(value);
+    const totalUsage = readTokenUsage(getRecord(record, "totalUsage"));
+    const runUsage = readTokenUsage(getRecord(record, "runUsage"));
+    return totalUsage || runUsage ? { ...(totalUsage ? { totalUsage } : {}), ...(runUsage ? { runUsage } : {}) } : undefined;
+}
+export async function fetchCursorCloudRawUsage(options) {
+    if (!options.apiKey || typeof options.fetchImpl !== "function" && typeof fetch !== "function")
+        return undefined;
+    try {
+        const baseUrl = options.baseUrl ?? DEFAULT_CURSOR_CLOUD_API_BASE_URL;
+        const url = new URL(`/v1/agents/${encodeURIComponent(options.agentId)}/usage`, baseUrl);
+        if (options.runId)
+            url.searchParams.set("runId", options.runId);
+        const fetchImpl = options.fetchImpl ?? fetch;
+        const body = asRecord(await fetchJsonWithAbortTimeout(fetchImpl, url, {
+            headers: {
+                Authorization: `Bearer ${options.apiKey}`,
+                "x-cursor-client-type": "sdk",
+            },
+        }, options.timeoutMs));
+        const runs = getArray(body, "runs") ?? [];
+        const matchingRun = options.runId
+            ? runs.map(asRecord).find((run) => getString(run, "id") === options.runId)
+            : undefined;
+        return normalizeUsage({
+            totalUsage: getRecord(body, "totalUsage"),
+            runUsage: getRecord(matchingRun, "usage"),
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+function mapCursorSdkAgentUsageToCloudReport(value, runId) {
+    const record = asRecord(value);
+    const runs = (getArray(record, "runs") ?? []).map(asRecord);
+    const matchingRun = runId ? runs.find((run) => getString(run, "runId") === runId) : undefined;
+    return normalizeUsage({
+        totalUsage: getRecord(record, "usage"),
+        runUsage: getRecord(matchingRun, "usage"),
+    });
+}
+export async function collectCursorCloudRunReport(options) {
+    const listArtifacts = options.agent.listArtifacts;
+    const sdkUsage = options.agentUsage !== undefined
+        ? mapCursorSdkAgentUsageToCloudReport(options.agentUsage, options.run.id)
+        : typeof options.agent.getUsage === "function"
+            ? mapCursorSdkAgentUsageToCloudReport(await withTimeout(Promise.resolve(options.agent.getUsage({ runId: options.run.id }))), options.run.id)
+            : undefined;
+    const [artifactResult, restUsage] = await Promise.all([
+        typeof listArtifacts === "function" ? withTimeout(listArtifacts.call(options.agent)) : undefined,
+        sdkUsage ? undefined : fetchCursorCloudRawUsage({ agentId: options.run.agentId, runId: options.run.id, apiKey: options.apiKey }),
+    ]);
+    const usage = sdkUsage ?? restUsage;
+    const waitBranches = getArray(getRecord(asRecord(options.waitResult), "git"), "branches");
+    const runBranches = getArray(getRecord(asRecord(options.run), "git"), "branches");
+    return {
+        agentId: options.run.agentId,
+        runId: options.run.id,
+        branches: normalizeBranches(waitBranches ?? runBranches),
+        artifacts: normalizeArtifacts(artifactResult),
+        usage: normalizeUsage(usage),
+    };
+}
+function formatTokenUsage(usage) {
+    const parts = [
+        `input ${usage.inputTokens.toLocaleString("en-US")}`,
+        `output ${usage.outputTokens.toLocaleString("en-US")}`,
+        `cache read ${usage.cacheReadTokens.toLocaleString("en-US")}`,
+        `cache write ${usage.cacheWriteTokens.toLocaleString("en-US")}`,
+        `total ${usage.totalTokens.toLocaleString("en-US")}`,
+    ];
+    if (usage.reasoningTokens !== undefined)
+        parts.splice(2, 0, `reasoning ${usage.reasoningTokens.toLocaleString("en-US")}`);
+    return parts.join(", ");
+}
+function remoteDisplayString(value, maxLength, apiKey) {
+    return typeof value === "string" ? truncateCursorDisplayLine(scrubSensitiveText(value, apiKey), maxLength) : "";
+}
+function formatBranchLine(branch, apiKey) {
+    const lines = [];
+    const branchName = remoteDisplayString(branch.branch, MAX_CLOUD_BRANCH_DISPLAY_LENGTH, apiKey);
+    const repoUrl = remoteDisplayString(branch.repoUrl, MAX_CLOUD_REPO_DISPLAY_LENGTH, apiKey);
+    const prUrl = remoteDisplayString(branch.prUrl, MAX_CLOUD_REPO_DISPLAY_LENGTH, apiKey);
+    if (branchName)
+        lines.push(`- branch: ${branchName}${repoUrl ? ` (${repoUrl})` : ""}`);
+    if (prUrl)
+        lines.push(`- PR: ${prUrl}`);
+    return lines;
+}
+export function formatCursorCloudRunReport(report, options = {}) {
+    const agentId = remoteDisplayString(report.agentId, MAX_CLOUD_ID_DISPLAY_LENGTH, options.apiKey) || "unknown";
+    const runId = remoteDisplayString(report.runId, MAX_CLOUD_ID_DISPLAY_LENGTH, options.apiKey) || "unknown";
+    const branches = normalizeBranches(report.branches);
+    const artifacts = normalizeArtifacts(report.artifacts);
+    const lines = ["Cursor cloud run:", `- agent: ${agentId}`, `- run: ${runId}`];
+    for (const branch of branches.slice(0, MAX_CLOUD_REPORT_BRANCHES))
+        lines.push(...formatBranchLine(branch, options.apiKey));
+    if (branches.length > MAX_CLOUD_REPORT_BRANCHES)
+        lines.push(`- branches: +${branches.length - MAX_CLOUD_REPORT_BRANCHES} more`);
+    if (artifacts) {
+        if (artifacts.length === 0) {
+            lines.push("- artifacts: none");
+        }
+        else {
+            lines.push("- artifacts:");
+            for (const artifact of artifacts.slice(0, MAX_CLOUD_REPORT_ARTIFACTS)) {
+                const path = remoteDisplayString(artifact.path, MAX_CLOUD_ARTIFACT_DISPLAY_LENGTH, options.apiKey);
+                const updatedAt = remoteDisplayString(artifact.updatedAt, MAX_CLOUD_ARTIFACT_DISPLAY_LENGTH, options.apiKey);
+                lines.push(`  - ${path} (${artifact.sizeBytes.toLocaleString("en-US")} bytes, updated ${updatedAt})`);
+            }
+            if (artifacts.length > MAX_CLOUD_REPORT_ARTIFACTS)
+                lines.push(`  - +${artifacts.length - MAX_CLOUD_REPORT_ARTIFACTS} more`);
+        }
+    }
+    const normalizedUsage = normalizeUsage(report.usage);
+    const usage = normalizedUsage?.runUsage ?? normalizedUsage?.totalUsage;
+    if (usage)
+        lines.push(`- raw usage (display only): ${formatTokenUsage(usage)}`);
+    return scrubSensitiveText(`${lines.join("\n")}\n`, options.apiKey);
+}

package/dist/cursor-compact-tool-summary.js

@@ -0,0 +1,75 @@
+import { isAbsolute, relative, win32 } from "node:path";
+import { asRecord, getRecord, getString } from "./cursor-record-utils.js";
+import { formatDisplayPath } from "./cursor-transcript-utils.js";
+function isWindowsAbsolutePath(path) {
+    return /^[A-Za-z]:[\\/]/.test(path) || path.startsWith("\\\\");
+}
+export function formatCursorCompactToolPath(path, options) {
+    const trimmed = path?.trim();
+    if (!trimmed)
+        return undefined;
+    const normalized = trimmed.replace(/\\/g, "/");
+    if (normalized === "~" || normalized.startsWith("~/") || /^~[^/]+(?:\/|$)/.test(normalized))
+        return undefined;
+    if (normalized.split("/").includes(".."))
+        return undefined;
+    if (/^[A-Za-z]:(?!\/)/.test(normalized))
+        return undefined;
+    if (isWindowsAbsolutePath(trimmed)) {
+        const cwd = options.cwd;
+        if (!cwd || !isWindowsAbsolutePath(cwd))
+            return undefined;
+        const relativePath = win32.relative(cwd, trimmed);
+        if (!relativePath || relativePath.startsWith("..") || isWindowsAbsolutePath(relativePath))
+            return undefined;
+        return relativePath.replace(/\\/g, "/");
+    }
+    if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(normalized))
+        return undefined;
+    if (isAbsolute(trimmed)) {
+        const cwd = options.cwd;
+        if (!cwd)
+            return undefined;
+        const relativePath = relative(cwd, trimmed);
+        if (!relativePath || relativePath.startsWith("..") || isAbsolute(relativePath))
+            return undefined;
+        return relativePath.replace(/\\/g, "/");
+    }
+    return formatDisplayPath(normalized, options.cwd);
+}
+function getNestedRecord(record, ...keys) {
+    let current = record;
+    for (const key of keys) {
+        current = getRecord(current, key);
+        if (!current)
+            return undefined;
+    }
+    return current;
+}
+function summarizeShellTool(args, resultValue) {
+    const command = getString(args, "command");
+    const stdout = getString(resultValue, "stdout");
+    const stderr = getString(resultValue, "stderr");
+    return [command ? `$ ${command}` : "shell", stdout, stderr].filter((part) => Boolean(part)).join("\n");
+}
+export function summarizeCursorCompactToolCall(toolName, args, result, options) {
+    if (!toolName)
+        return undefined;
+    const compactName = toolName.replace(/\s+/g, " ").trim() || "unknown";
+    if (compactName === "shell")
+        return summarizeShellTool(args, getNestedRecord(result, "value"));
+    const path = formatCursorCompactToolPath(getString(args, "path"), options);
+    if (path)
+        return `${compactName} ${path}`;
+    const query = getString(args, "query") ?? getString(args, "pattern");
+    if (query)
+        return `${compactName} ${query}`;
+    return compactName;
+}
+export function summarizeCursorCompactConversationToolCall(step, options) {
+    const record = asRecord(step);
+    if (getString(record, "type") !== "toolCall")
+        return undefined;
+    const message = getRecord(record, "message");
+    return summarizeCursorCompactToolCall(getString(message, "type"), getRecord(message, "args"), getRecord(message, "result"), options);
+}