codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/core/src/services/global-settings.test.ts

@@ -0,0 +1,352 @@
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { ITelemetryService } from "@cline/shared";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+	GlobalSettingsSchema,
+	readGlobalSettings,
+	setAutoUpdateEnabledGlobally,
+	setDisabledPlugin,
+	setDisabledTools,
+	setTelemetryOptOutGlobally,
+	writeGlobalSettings,
+} from "./global-settings";
+
+describe("global-settings", () => {
+	const previousGlobalSettingsPath = process.env.CLINE_GLOBAL_SETTINGS_PATH;
+
+	afterEach(() => {
+		process.env.CLINE_GLOBAL_SETTINGS_PATH = previousGlobalSettingsPath;
+	});
+
+	it("defines the global settings file schema", () => {
+		expect(
+			GlobalSettingsSchema.parse({
+				disabledTools: [" read_files ", "read_files", "editor"],
+				disabledPlugins: ["/plugins/example.js", "/plugins/example.js"],
+			}),
+		).toEqual({
+			autoUpdateEnabled: true,
+			disabledPlugins: ["/plugins/example.js"],
+			disabledTools: ["editor", "read_files"],
+			telemetryOptOut: false,
+		});
+		expect(
+			GlobalSettingsSchema.parse({
+				disabledTools: [],
+				telemetryOptOut: true,
+			}),
+		).toEqual({ autoUpdateEnabled: true, telemetryOptOut: true });
+		expect(GlobalSettingsSchema.parse({ disabledTools: [] })).toEqual({
+			autoUpdateEnabled: true,
+			telemetryOptOut: false,
+		});
+		expect(
+			GlobalSettingsSchema.parse({
+				disabledTools: ["read_files"],
+				extra: true,
+			}),
+		).toEqual({
+			autoUpdateEnabled: true,
+			disabledTools: ["read_files"],
+			telemetryOptOut: false,
+		});
+		expect(
+			GlobalSettingsSchema.parse({
+				disabledTools: 42,
+				extra: true,
+				telemetryOptOut: true,
+			}),
+		).toEqual({
+			autoUpdateEnabled: true,
+			telemetryOptOut: true,
+		});
+		expect(
+			GlobalSettingsSchema.parse({
+				autoUpdateEnabled: false,
+			}),
+		).toEqual({
+			autoUpdateEnabled: false,
+			telemetryOptOut: false,
+		});
+	});
+
+	it("uses the schema when reading and writing settings", async () => {
+		const root = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+		try {
+			const settingsPath = join(root, "global-settings.json");
+			process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+
+			writeGlobalSettings({
+				disabledTools: [" editor ", "read_files", "editor"],
+				disabledPlugins: [],
+			});
+
+			expect(readGlobalSettings()).toEqual({
+				autoUpdateEnabled: true,
+				disabledTools: ["editor", "read_files"],
+				telemetryOptOut: false,
+			});
+			expect(JSON.parse(await readFile(settingsPath, "utf8"))).toEqual({
+				autoUpdateEnabled: true,
+				disabledTools: ["editor", "read_files"],
+				telemetryOptOut: false,
+			});
+
+			await writeFile(
+				settingsPath,
+				JSON.stringify({
+					disabledTools: ["read_files"],
+					extra: true,
+					telemetryOptOut: true,
+				}),
+			);
+			expect(readGlobalSettings()).toEqual({
+				autoUpdateEnabled: true,
+				disabledTools: ["read_files"],
+				telemetryOptOut: true,
+			});
+
+			await writeFile(
+				settingsPath,
+				JSON.stringify({
+					disabledTools: 42,
+					extra: true,
+					telemetryOptOut: true,
+				}),
+			);
+			expect(readGlobalSettings()).toEqual({
+				autoUpdateEnabled: true,
+				telemetryOptOut: true,
+			});
+		} finally {
+			await rm(root, { recursive: true, force: true });
+		}
+	});
+
+	it("preserves disabled tools and plugins across targeted updates", async () => {
+		const root = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+		try {
+			const settingsPath = join(root, "global-settings.json");
+			process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+
+			setDisabledPlugin("/plugins/example.js", true);
+			setDisabledTools(["read_files", "editor"], true);
+			setDisabledTools(["editor"], false);
+
+			expect(readGlobalSettings()).toEqual({
+				autoUpdateEnabled: true,
+				disabledPlugins: ["/plugins/example.js"],
+				disabledTools: ["read_files"],
+				telemetryOptOut: false,
+			});
+			expect(JSON.parse(await readFile(settingsPath, "utf8"))).toEqual({
+				autoUpdateEnabled: true,
+				disabledPlugins: ["/plugins/example.js"],
+				disabledTools: ["read_files"],
+				telemetryOptOut: false,
+			});
+		} finally {
+			await rm(root, { recursive: true, force: true });
+		}
+	});
+
+	it("records telemetry opt-out once when the setting changes to true", async () => {
+		const root = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+		try {
+			const settingsPath = join(root, "global-settings.json");
+			process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+			const captureRequired = vi.fn();
+			const telemetry = {
+				captureRequired,
+			} as unknown as ITelemetryService;
+
+			setTelemetryOptOutGlobally(true, { telemetry });
+			setTelemetryOptOutGlobally(true, { telemetry });
+			setTelemetryOptOutGlobally(false, { telemetry });
+
+			expect(captureRequired).toHaveBeenCalledTimes(1);
+			expect(captureRequired).toHaveBeenCalledWith("user.opt_out", undefined);
+			expect(readGlobalSettings()).toEqual({
+				autoUpdateEnabled: true,
+				telemetryOptOut: false,
+			});
+		} finally {
+			await rm(root, { recursive: true, force: true });
+		}
+	});
+
+	it("preserves other settings when auto update is changed", async () => {
+		const root = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+		try {
+			const settingsPath = join(root, "global-settings.json");
+			process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+
+			writeGlobalSettings({
+				disabledTools: ["editor"],
+				telemetryOptOut: true,
+			});
+			setAutoUpdateEnabledGlobally(false);
+
+			expect(readGlobalSettings()).toEqual({
+				autoUpdateEnabled: false,
+				disabledTools: ["editor"],
+				telemetryOptOut: true,
+			});
+		} finally {
+			await rm(root, { recursive: true, force: true });
+		}
+	});
+
+	describe("caching", () => {
+		it("invalidates the cache when writeGlobalSettings is called", async () => {
+			const root = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+			try {
+				const settingsPath = join(root, "global-settings.json");
+				process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+				writeGlobalSettings({ disabledTools: ["editor"] });
+				readGlobalSettings();
+
+				writeGlobalSettings({ disabledTools: ["read_files"] });
+
+				expect(readGlobalSettings()).toEqual({
+					autoUpdateEnabled: true,
+					disabledTools: ["read_files"],
+					telemetryOptOut: false,
+				});
+			} finally {
+				await rm(root, { recursive: true, force: true });
+			}
+		});
+
+		it("picks up external writes via mtime change", async () => {
+			const root = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+			try {
+				const settingsPath = join(root, "global-settings.json");
+				process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+				writeGlobalSettings({ disabledTools: ["editor"] });
+				readGlobalSettings();
+
+				await writeFile(
+					settingsPath,
+					JSON.stringify({ disabledTools: ["read_files"] }),
+				);
+
+				expect(readGlobalSettings()).toEqual({
+					autoUpdateEnabled: true,
+					disabledTools: ["read_files"],
+					telemetryOptOut: false,
+				});
+			} finally {
+				await rm(root, { recursive: true, force: true });
+			}
+		});
+
+		it("keys the cache by resolved path so switching files returns the right value", async () => {
+			const rootA = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+			const rootB = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+			try {
+				const pathA = join(rootA, "global-settings.json");
+				const pathB = join(rootB, "global-settings.json");
+
+				process.env.CLINE_GLOBAL_SETTINGS_PATH = pathA;
+				writeGlobalSettings({ disabledTools: ["editor"] });
+				expect(readGlobalSettings()).toEqual({
+					autoUpdateEnabled: true,
+					disabledTools: ["editor"],
+					telemetryOptOut: false,
+				});
+
+				process.env.CLINE_GLOBAL_SETTINGS_PATH = pathB;
+				writeGlobalSettings({ disabledTools: ["read_files"] });
+				expect(readGlobalSettings()).toEqual({
+					autoUpdateEnabled: true,
+					disabledTools: ["read_files"],
+					telemetryOptOut: false,
+				});
+
+				process.env.CLINE_GLOBAL_SETTINGS_PATH = pathA;
+				expect(readGlobalSettings()).toEqual({
+					autoUpdateEnabled: true,
+					disabledTools: ["editor"],
+					telemetryOptOut: false,
+				});
+			} finally {
+				await rm(rootA, { recursive: true, force: true });
+				await rm(rootB, { recursive: true, force: true });
+			}
+		});
+
+		it("returns the default value when the settings file does not exist", async () => {
+			const root = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+			try {
+				const settingsPath = join(root, "missing-global-settings.json");
+				process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+
+				expect(readGlobalSettings()).toEqual({
+					autoUpdateEnabled: true,
+					telemetryOptOut: false,
+				});
+				expect(readGlobalSettings()).toEqual({
+					autoUpdateEnabled: true,
+					telemetryOptOut: false,
+				});
+			} finally {
+				await rm(root, { recursive: true, force: true });
+			}
+		});
+
+		it("returns a frozen value so callers cannot mutate the cache", async () => {
+			const root = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+			try {
+				const settingsPath = join(root, "global-settings.json");
+				process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+				writeGlobalSettings({
+					disabledTools: ["editor"],
+					disabledPlugins: ["/plugins/example.js"],
+				});
+
+				const settings = readGlobalSettings();
+
+				expect(Object.isFrozen(settings)).toBe(true);
+				expect(Object.isFrozen(settings.disabledTools)).toBe(true);
+				expect(Object.isFrozen(settings.disabledPlugins)).toBe(true);
+				expect(() => {
+					(settings as { telemetryOptOut: boolean }).telemetryOptOut = true;
+				}).toThrow();
+				expect(() => {
+					settings.disabledTools?.push("malicious");
+				}).toThrow();
+			} finally {
+				await rm(root, { recursive: true, force: true });
+			}
+		});
+
+		it("transitions from missing-file default to fresh value once the file is created", async () => {
+			const root = await mkdtemp(join(tmpdir(), "core-global-settings-"));
+			try {
+				const settingsPath = join(root, "global-settings.json");
+				process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
+
+				expect(readGlobalSettings()).toEqual({
+					autoUpdateEnabled: true,
+					telemetryOptOut: false,
+				});
+
+				await writeFile(
+					settingsPath,
+					JSON.stringify({ disabledTools: ["editor"] }),
+				);
+
+				expect(readGlobalSettings()).toEqual({
+					autoUpdateEnabled: true,
+					disabledTools: ["editor"],
+					telemetryOptOut: false,
+				});
+			} finally {
+				await rm(root, { recursive: true, force: true });
+			}
+		});
+	});
+});

codna/agent-core/vendor/cline/sdk/packages/core/src/services/global-settings.ts

@@ -0,0 +1,324 @@
+import { mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import type { AgentConfig, AgentTool, ITelemetryService } from "@cline/shared";
+import { resolveGlobalSettingsPath } from "@cline/shared/storage";
+import { z } from "zod";
+import { captureTelemetryOptOut } from "./telemetry/core-events";
+
+type AgentExtension = NonNullable<AgentConfig["extensions"]>[number];
+type AgentExtensionApi = Parameters<NonNullable<AgentExtension["setup"]>>[0];
+
+const GlobalSettingsStringListSchema = z
+	.preprocess(
+		(value) =>
+			Array.isArray(value)
+				? value
+						.filter((entry): entry is string => typeof entry === "string")
+						.map((entry) => entry.trim())
+						.filter(Boolean)
+				: undefined,
+		z.array(z.string()).optional(),
+	)
+	.transform((entries) => {
+		if (!entries) {
+			return undefined;
+		}
+		const normalized = [...new Set(entries)].sort((left, right) =>
+			left.localeCompare(right),
+		);
+		return normalized.length > 0 ? normalized : undefined;
+	});
+
+export const GlobalSettingsSchema = z
+	.object({
+		telemetryOptOut: z.boolean().default(false).catch(false),
+		autoUpdateEnabled: z.boolean().default(true).catch(true),
+		disabledTools: GlobalSettingsStringListSchema.optional(),
+		disabledPlugins: GlobalSettingsStringListSchema.optional(),
+	})
+	.strip()
+	.transform((settings) => {
+		const normalized: {
+			telemetryOptOut: boolean;
+			autoUpdateEnabled: boolean;
+			disabledTools?: string[];
+			disabledPlugins?: string[];
+		} = {
+			autoUpdateEnabled: settings.autoUpdateEnabled,
+			telemetryOptOut: settings.telemetryOptOut,
+		};
+		if (settings.disabledTools?.length) {
+			normalized.disabledTools = settings.disabledTools;
+		}
+		if (settings.disabledPlugins?.length) {
+			normalized.disabledPlugins = settings.disabledPlugins;
+		}
+		return normalized;
+	});
+
+export type GlobalSettings = z.infer<typeof GlobalSettingsSchema>;
+
+export interface WriteGlobalSettingsOptions {
+	telemetry?: ITelemetryService;
+}
+
+function defaultGlobalSettings(): GlobalSettings {
+	return GlobalSettingsSchema.parse({});
+}
+
+interface CachedSettings {
+	path: string;
+	mtimeMs: number;
+	size: number;
+	value: GlobalSettings;
+}
+
+let settingsCache: CachedSettings | undefined;
+
+function invalidateSettingsCache(): void {
+	settingsCache = undefined;
+}
+
+function freezeSettings(value: GlobalSettings): GlobalSettings {
+	if (value.disabledTools) {
+		Object.freeze(value.disabledTools);
+	}
+	if (value.disabledPlugins) {
+		Object.freeze(value.disabledPlugins);
+	}
+	return Object.freeze(value);
+}
+
+function loadSettingsFromDisk(filePath: string): GlobalSettings {
+	let raw: string;
+	try {
+		raw = readFileSync(filePath, "utf8");
+	} catch {
+		return defaultGlobalSettings();
+	}
+	try {
+		const result = GlobalSettingsSchema.safeParse(JSON.parse(raw));
+		return result.success ? result.data : defaultGlobalSettings();
+	} catch {
+		return defaultGlobalSettings();
+	}
+}
+
+function getCachedSettings(): CachedSettings {
+	const filePath = resolveGlobalSettingsPath();
+	const stats = statSync(filePath, { throwIfNoEntry: false });
+	const mtimeMs = stats?.mtimeMs ?? 0;
+	const size = stats?.size ?? 0;
+
+	const cached = settingsCache;
+	if (
+		cached &&
+		cached.path === filePath &&
+		cached.mtimeMs === mtimeMs &&
+		cached.size === size
+	) {
+		return cached;
+	}
+
+	const value = freezeSettings(
+		stats ? loadSettingsFromDisk(filePath) : defaultGlobalSettings(),
+	);
+	settingsCache = { path: filePath, mtimeMs, size, value };
+	return settingsCache;
+}
+
+export function readGlobalSettings(): GlobalSettings {
+	return getCachedSettings().value;
+}
+
+export function writeGlobalSettings(
+	settings: z.input<typeof GlobalSettingsSchema>,
+	options: WriteGlobalSettingsOptions = {},
+): void {
+	const filePath = resolveGlobalSettingsPath();
+	const previous = readGlobalSettings();
+	mkdirSync(dirname(filePath), { recursive: true });
+	const normalized = GlobalSettingsSchema.parse(settings);
+	if (!previous.telemetryOptOut && normalized.telemetryOptOut) {
+		captureTelemetryOptOut(options.telemetry);
+	}
+	writeFileSync(filePath, `${JSON.stringify(normalized, null, 2)}\n`, "utf8");
+	invalidateSettingsCache();
+}
+
+export function isTelemetryOptedOutGlobally(): boolean {
+	return readGlobalSettings().telemetryOptOut;
+}
+
+export function setTelemetryOptOutGlobally(
+	telemetryOptOut: boolean,
+	options: WriteGlobalSettingsOptions = {},
+): void {
+	writeGlobalSettings(
+		{
+			...readGlobalSettings(),
+			telemetryOptOut,
+		},
+		options,
+	);
+}
+
+export function isAutoUpdateEnabledGlobally(): boolean {
+	return readGlobalSettings().autoUpdateEnabled;
+}
+
+export function setAutoUpdateEnabledGlobally(
+	autoUpdateEnabled: boolean,
+	options: WriteGlobalSettingsOptions = {},
+): void {
+	writeGlobalSettings(
+		{
+			...readGlobalSettings(),
+			autoUpdateEnabled,
+		},
+		options,
+	);
+}
+
+export function resolveDisabledToolNames(
+	disabledToolNames?: ReadonlyArray<string>,
+): Set<string> {
+	return new Set(disabledToolNames ?? readGlobalSettings().disabledTools ?? []);
+}
+
+export function resolveDisabledPluginPaths(
+	disabledPluginPaths?: ReadonlyArray<string>,
+): Set<string> {
+	return new Set(
+		disabledPluginPaths ?? readGlobalSettings().disabledPlugins ?? [],
+	);
+}
+
+export function isToolDisabledGlobally(toolName: string): boolean {
+	return resolveDisabledToolNames().has(toolName);
+}
+
+export function toggleDisabledTool(toolName: string): boolean {
+	const settings = readGlobalSettings();
+	const disabled = new Set(settings.disabledTools ?? []);
+	const wasDisabled = disabled.has(toolName);
+	if (wasDisabled) {
+		disabled.delete(toolName);
+	} else {
+		disabled.add(toolName);
+	}
+	writeGlobalSettings({ ...settings, disabledTools: [...disabled] });
+	return !wasDisabled;
+}
+
+export function setDisabledTools(
+	toolNames: ReadonlyArray<string>,
+	disabledValue: boolean,
+): void {
+	const names = [
+		...new Set(toolNames.map((name) => name.trim()).filter(Boolean)),
+	];
+	if (names.length === 0) {
+		return;
+	}
+
+	const settings = readGlobalSettings();
+	const disabled = resolveDisabledToolNames(settings.disabledTools);
+	for (const name of names) {
+		if (disabledValue) {
+			disabled.add(name);
+		} else {
+			disabled.delete(name);
+		}
+	}
+	writeGlobalSettings({ ...settings, disabledTools: [...disabled] });
+}
+
+export function setToolDisabledGlobally(
+	toolName: string,
+	disabled: boolean,
+): boolean {
+	setDisabledTools([toolName], disabled);
+	return disabled;
+}
+
+export function isPluginDisabledGlobally(pluginPath: string): boolean {
+	return resolveDisabledPluginPaths().has(pluginPath);
+}
+
+export function setDisabledPlugin(
+	pluginPath: string,
+	disabledValue: boolean,
+): void {
+	const path = pluginPath.trim();
+	if (!path) {
+		return;
+	}
+
+	const settings = readGlobalSettings();
+	const disabled = resolveDisabledPluginPaths(settings.disabledPlugins);
+	if (disabledValue) {
+		disabled.add(path);
+	} else {
+		disabled.delete(path);
+	}
+	writeGlobalSettings({ ...settings, disabledPlugins: [...disabled] });
+}
+
+export function filterDisabledPluginPaths(
+	pluginPaths: ReadonlyArray<string>,
+	disabledPluginPaths?: ReadonlyArray<string>,
+): string[] {
+	const disabled = resolveDisabledPluginPaths(disabledPluginPaths);
+	if (disabled.size === 0) {
+		return [...pluginPaths];
+	}
+	return pluginPaths.filter((pluginPath) => !disabled.has(pluginPath));
+}
+
+export function filterDisabledTools<T extends Pick<AgentTool, "name">>(
+	tools: ReadonlyArray<T>,
+	disabledToolNames?: ReadonlyArray<string>,
+): T[] {
+	const disabled = resolveDisabledToolNames(disabledToolNames);
+	if (disabled.size === 0) {
+		return [...tools];
+	}
+	return tools.filter((tool) => !disabled.has(tool.name));
+}
+
+export function filterExtensionToolRegistrations(
+	extensions: AgentConfig["extensions"],
+	disabledToolNames?: ReadonlyArray<string>,
+): AgentConfig["extensions"] {
+	if (!extensions || extensions.length === 0) {
+		return extensions;
+	}
+
+	const disabled = resolveDisabledToolNames(disabledToolNames);
+	if (disabled.size === 0) {
+		return extensions;
+	}
+
+	return extensions.map((extension) => {
+		if (!extension.setup) {
+			return extension;
+		}
+
+		return {
+			...extension,
+			setup: (api: AgentExtensionApi, ctx) =>
+				extension.setup?.(
+					{
+						...api,
+						registerTool: (tool) => {
+							if (!disabled.has(tool.name)) {
+								api.registerTool(tool);
+							}
+						},
+					},
+					ctx,
+				),
+		};
+	});
+}