pi-cursor-sdk 0.1.16 → 0.1.18

package/src/cursor-question-tool.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI, ExtensionContext, ExtensionHandler, SessionStartEvent } from "@earendil-works/pi-coding-agent";
+import type { BeforeAgentStartEvent, ExtensionAPI, ExtensionContext, ExtensionHandler, SessionStartEvent, TurnStartEvent } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { resolveCursorPiToolBridgeEnabled } from "./cursor-pi-tool-bridge.js";
@@ -36,6 +36,8 @@ interface CursorQuestionDetails {
 
 interface CursorQuestionToolExtensionApi extends Pick<ExtensionAPI, "getActiveTools" | "registerTool" | "setActiveTools"> {
 	on(event: "session_start", handler: ExtensionHandler<SessionStartEvent>): void;
+	on(event: "before_agent_start", handler: ExtensionHandler<BeforeAgentStartEvent>): void;
+	on(event: "turn_start", handler: ExtensionHandler<TurnStartEvent>): void;
 	on(event: "model_select", handler: (event: { model: ExtensionContext["model"] }, ctx: ExtensionContext) => Promise<void> | void): void;
 }
 
@@ -246,6 +248,12 @@ export function registerCursorQuestionTool(pi: CursorQuestionToolExtensionApi):
 	pi.on("session_start", (_event, ctx) => {
 		syncCursorQuestionToolForModel(pi, ctx.model);
 	});
+	pi.on("before_agent_start", (_event, ctx) => {
+		syncCursorQuestionToolForModel(pi, ctx.model);
+	});
+	pi.on("turn_start", (_event, ctx) => {
+		syncCursorQuestionToolForModel(pi, ctx.model);
+	});
 	pi.on("model_select", (event) => {
 		syncCursorQuestionToolForModel(pi, event.model);
 	});

package/src/cursor-record-utils.ts

@@ -0,0 +1,26 @@
+export function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined;
+}
+
+export function getField(value: unknown, field: string): unknown {
+	return asRecord(value)?.[field];
+}
+
+export function hasUsableText(value: string | undefined): value is string {
+	return typeof value === "string" && value.trim().length > 0;
+}
+
+export function getFirstStringByKeys(
+	record: Record<string, unknown> | undefined,
+	keys: readonly string[],
+	options?: { nonEmpty?: boolean },
+): string | undefined {
+	if (!record) return undefined;
+	for (const key of keys) {
+		const value = record[key];
+		if (typeof value !== "string") continue;
+		if (options?.nonEmpty && !value) continue;
+		return value;
+	}
+	return undefined;
+}

package/src/cursor-sdk-output-filter.ts

@@ -0,0 +1,100 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+const cursorSdkOutputSuppression = new AsyncLocalStorage<boolean>();
+
+export const CURSOR_SDK_STARTUP_NOISE_PATTERNS = [
+	"[hooks]",
+	"managed_skills.",
+	"CursorPluginsAgentSkillsService load completed",
+	"LocalCursorRulesService load completed",
+	"AgentSkillsCursorRulesService load completed",
+	"Error initializing ignore mapping for",
+	"Ripgrep path not configured. Call configureRipgrepPath() at startup.",
+] as const;
+
+export function isCursorSdkOutputSuppressed(): boolean {
+	return cursorSdkOutputSuppression.getStore() === true;
+}
+
+export function suppressCursorSdkOutput<T>(operation: () => Promise<T>): Promise<T> {
+	return cursorSdkOutputSuppression.run(true, operation);
+}
+
+export function isCursorSdkStartupNoise(text: string): boolean {
+	return CURSOR_SDK_STARTUP_NOISE_PATTERNS.some((pattern) => text.includes(pattern));
+}
+
+function createFilteredProcessWrite<TWrite extends typeof process.stdout.write>(write: TWrite, stream: NodeJS.WriteStream): TWrite {
+	return ((
+		chunk: string | Uint8Array,
+		encodingOrCallback?: BufferEncoding | ((error?: Error | null) => void),
+		callback?: (error?: Error | null) => void,
+	): boolean => {
+		const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+		if (isCursorSdkOutputSuppressed() || isCursorSdkStartupNoise(text)) {
+			const done = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+			done?.();
+			return true;
+		}
+		return write.call(stream, chunk as string, encodingOrCallback as BufferEncoding, callback);
+	}) as TWrite;
+}
+
+function createFilteredConsoleMethod<TMethod extends typeof console.log>(method: TMethod): TMethod {
+	return ((...args: Parameters<TMethod>): void => {
+		const text = args.map((arg) => (typeof arg === "string" ? arg : String(arg))).join(" ");
+		if (isCursorSdkOutputSuppressed() || isCursorSdkStartupNoise(text)) return;
+		method(...args);
+	}) as TMethod;
+}
+
+interface CursorSdkOutputFilterOriginals {
+	stdoutWrite: typeof process.stdout.write;
+	stderrWrite: typeof process.stderr.write;
+	consoleLog: typeof console.log;
+	consoleInfo: typeof console.info;
+	consoleWarn: typeof console.warn;
+	consoleError: typeof console.error;
+	consoleDebug: typeof console.debug;
+}
+
+let activeOutputFilterInstalls = 0;
+let outputFilterOriginals: CursorSdkOutputFilterOriginals | undefined;
+
+export function installCursorSdkOutputFilter(): () => void {
+	if (activeOutputFilterInstalls === 0) {
+		outputFilterOriginals = {
+			stdoutWrite: process.stdout.write,
+			stderrWrite: process.stderr.write,
+			consoleLog: console.log,
+			consoleInfo: console.info,
+			consoleWarn: console.warn,
+			consoleError: console.error,
+			consoleDebug: console.debug,
+		};
+		process.stdout.write = createFilteredProcessWrite(outputFilterOriginals.stdoutWrite, process.stdout);
+		process.stderr.write = createFilteredProcessWrite(outputFilterOriginals.stderrWrite, process.stderr) as typeof process.stderr.write;
+		console.log = createFilteredConsoleMethod(outputFilterOriginals.consoleLog);
+		console.info = createFilteredConsoleMethod(outputFilterOriginals.consoleInfo);
+		console.warn = createFilteredConsoleMethod(outputFilterOriginals.consoleWarn);
+		console.error = createFilteredConsoleMethod(outputFilterOriginals.consoleError);
+		console.debug = createFilteredConsoleMethod(outputFilterOriginals.consoleDebug);
+	}
+	activeOutputFilterInstalls += 1;
+
+	let restored = false;
+	return () => {
+		if (restored) return;
+		restored = true;
+		activeOutputFilterInstalls = Math.max(activeOutputFilterInstalls - 1, 0);
+		if (activeOutputFilterInstalls > 0 || !outputFilterOriginals) return;
+		process.stdout.write = outputFilterOriginals.stdoutWrite;
+		process.stderr.write = outputFilterOriginals.stderrWrite;
+		console.log = outputFilterOriginals.consoleLog;
+		console.info = outputFilterOriginals.consoleInfo;
+		console.warn = outputFilterOriginals.consoleWarn;
+		console.error = outputFilterOriginals.consoleError;
+		console.debug = outputFilterOriginals.consoleDebug;
+		outputFilterOriginals = undefined;
+	};
+}

package/src/cursor-sensitive-text.ts

@@ -0,0 +1,37 @@
+import type { CursorPiToolDisplay } from "./cursor-transcript-utils.js";
+
+function escapeRegExp(value: string): string {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export function scrubSensitiveText(text: string, apiKey?: string): string {
+	let scrubbed = text;
+	const trimmedKey = apiKey?.trim();
+	if (trimmedKey) {
+		scrubbed = scrubbed.replace(new RegExp(escapeRegExp(trimmedKey), "g"), "[redacted]");
+	}
+	return scrubbed
+		.replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [redacted]")
+		.replace(/((?:^|[\s,{])cookie["']?\s*[:=]\s*["']?)[^\n]+/gi, "$1[redacted]")
+		.replace(
+			/((?:authorization|api[_-]?key|apiKey|token|session(?:[_-]?id)?)["']?\s*[:=]\s*["']?)[^"'\s,;}]+/gi,
+			"$1[redacted]",
+		);
+}
+
+function scrubDisplayValue(value: unknown, apiKey?: string): unknown {
+	if (typeof value === "string") return scrubSensitiveText(value, apiKey);
+	if (Array.isArray(value)) return value.map((entry) => scrubDisplayValue(entry, apiKey));
+	if (value && typeof value === "object") {
+		return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, scrubDisplayValue(entry, apiKey)]));
+	}
+	return value;
+}
+
+export function scrubPiToolDisplay(display: CursorPiToolDisplay, apiKey?: string): CursorPiToolDisplay {
+	return {
+		...display,
+		args: scrubDisplayValue(display.args, apiKey) as Record<string, unknown>,
+		result: scrubDisplayValue(display.result, apiKey) as CursorPiToolDisplay["result"],
+	};
+}