codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/shared/src/remote-config/blob-storage.ts

@@ -0,0 +1,416 @@
+import { createHmac } from "node:crypto";
+import { basename } from "node:path";
+import { AwsClient } from "aws4fetch";
+import type {
+	PromptUploading,
+	RemoteConfig,
+	S3AccessKeySettings,
+} from "./schema";
+
+export interface RemoteConfigBlobStoreSettings {
+	bucket: string;
+	adapterType: "s3" | "r2" | "azure";
+	accessKeyId: string;
+	secretAccessKey: string;
+	region?: string;
+	endpoint?: string;
+	accountId?: string;
+}
+
+export interface RemoteConfigBlobStoreTarget {
+	bucket: string;
+	adapterType: "s3" | "r2" | "azure";
+	region?: string;
+	endpoint?: string;
+	accountId?: string;
+}
+
+export interface RemoteConfigBlobStorageAdapter {
+	write(path: string, value: string): Promise<void>;
+}
+
+export interface RemoteConfigSessionBlobUploadMetadata {
+	version: 1;
+	storage: RemoteConfigBlobStoreTarget;
+	keyPrefix?: string;
+	userDistinctId?: string;
+}
+
+export interface RemoteConfigSessionMetadataRow {
+	metadata?: Record<string, unknown> | null;
+}
+
+export interface RemoteConfigSessionMessagesUploadInput {
+	sessionId: string;
+	path: string;
+	contents: string;
+	row?: RemoteConfigSessionMetadataRow;
+}
+
+export interface RemoteConfigSessionMessagesArtifactUploader {
+	uploadMessagesFile(
+		input: RemoteConfigSessionMessagesUploadInput,
+	): Promise<void>;
+}
+
+export const REMOTE_CONFIG_SESSION_BLOB_UPLOAD_METADATA_KEY =
+	"enterprise.blobUpload";
+
+const sessionBlobStoreSettings = new Map<
+	string,
+	RemoteConfigBlobStoreSettings
+>();
+
+function accessSettingsToBlobStorage(
+	adapterType: RemoteConfigBlobStoreSettings["adapterType"],
+	settings: S3AccessKeySettings,
+): RemoteConfigBlobStoreSettings {
+	return {
+		adapterType,
+		accessKeyId: settings.accessKeyId,
+		secretAccessKey: settings.secretAccessKey,
+		region: settings.region,
+		bucket: settings.bucket,
+		endpoint: settings.endpoint,
+		accountId: settings.accountId,
+	};
+}
+
+function sanitizeBlobStoreTarget(
+	settings: RemoteConfigBlobStoreSettings,
+): RemoteConfigBlobStoreTarget {
+	return {
+		adapterType: settings.adapterType,
+		bucket: settings.bucket,
+		region: settings.region,
+		endpoint: settings.endpoint,
+		accountId: settings.accountId,
+	};
+}
+
+export function resolveBlobStoreSettingsFromPromptUploading(
+	promptUploading: PromptUploading | undefined,
+): RemoteConfigBlobStoreSettings | undefined {
+	if (!promptUploading || promptUploading.enabled !== true) {
+		return undefined;
+	}
+	if (
+		promptUploading.type === "s3_access_keys" &&
+		promptUploading.s3AccessSettings
+	) {
+		return accessSettingsToBlobStorage("s3", promptUploading.s3AccessSettings);
+	}
+	if (
+		promptUploading.type === "r2_access_keys" &&
+		promptUploading.r2AccessSettings
+	) {
+		return accessSettingsToBlobStorage("r2", promptUploading.r2AccessSettings);
+	}
+	if (
+		promptUploading.type === "azure_access_keys" &&
+		promptUploading.azureAccessSettings
+	) {
+		return accessSettingsToBlobStorage(
+			"azure",
+			promptUploading.azureAccessSettings,
+		);
+	}
+	return undefined;
+}
+
+export function resolveBlobStoreSettingsFromRemoteConfig(
+	remoteConfig: RemoteConfig | undefined,
+): RemoteConfigBlobStoreSettings | undefined {
+	return resolveBlobStoreSettingsFromPromptUploading(
+		remoteConfig?.enterpriseTelemetry?.promptUploading,
+	);
+}
+
+export function buildRemoteConfigSessionBlobUploadMetadata(
+	remoteConfig: RemoteConfig | undefined,
+	userDistinctId?: string,
+): RemoteConfigSessionBlobUploadMetadata | undefined {
+	const storage = resolveBlobStoreSettingsFromRemoteConfig(remoteConfig);
+	if (!storage) {
+		return undefined;
+	}
+	return {
+		version: 1,
+		storage: sanitizeBlobStoreTarget(storage),
+		userDistinctId,
+	};
+}
+
+export function registerRemoteConfigSessionBlobUpload(
+	sessionId: string,
+	remoteConfig: RemoteConfig | undefined,
+	userDistinctId?: string,
+): RemoteConfigSessionBlobUploadMetadata | undefined {
+	const storage = resolveBlobStoreSettingsFromRemoteConfig(remoteConfig);
+	if (!storage) {
+		sessionBlobStoreSettings.delete(sessionId);
+		return undefined;
+	}
+	sessionBlobStoreSettings.set(sessionId, storage);
+	return {
+		version: 1,
+		storage: sanitizeBlobStoreTarget(storage),
+		userDistinctId,
+	};
+}
+
+export function clearRemoteConfigSessionBlobUpload(sessionId: string): void {
+	sessionBlobStoreSettings.delete(sessionId);
+}
+
+function createAdapter(
+	client: AwsClient,
+	endpoint: string,
+	bucket: string,
+): RemoteConfigBlobStorageAdapter {
+	const base = `${endpoint}/${bucket}`;
+	return {
+		async write(path: string, value: string): Promise<void> {
+			const response = await client.fetch(`${base}/${path}`, {
+				method: "PUT",
+				body: value,
+				headers: {
+					"Content-Type": "application/json; charset=utf-8",
+				},
+			});
+			if (!response.ok) {
+				throw new Error(`Failed to write ${path}: ${response.status}`);
+			}
+		},
+	};
+}
+
+function createS3Adapter(
+	settings: RemoteConfigBlobStoreSettings,
+): RemoteConfigBlobStorageAdapter | undefined {
+	const { bucket, accessKeyId, secretAccessKey } = settings;
+	if (!bucket || !accessKeyId || !secretAccessKey) {
+		return undefined;
+	}
+	const region = settings.region || "us-east-1";
+	const endpoint = settings.endpoint || `https://s3.${region}.amazonaws.com`;
+	return createAdapter(
+		new AwsClient({
+			region,
+			accessKeyId,
+			secretAccessKey,
+		}),
+		endpoint,
+		bucket,
+	);
+}
+
+function createR2Adapter(
+	settings: RemoteConfigBlobStoreSettings,
+): RemoteConfigBlobStorageAdapter | undefined {
+	const { accountId, endpoint, bucket, accessKeyId, secretAccessKey } =
+		settings;
+	if (
+		(!endpoint && !accountId) ||
+		!bucket ||
+		!accessKeyId ||
+		!secretAccessKey
+	) {
+		return undefined;
+	}
+	return createAdapter(
+		new AwsClient({
+			accessKeyId,
+			secretAccessKey,
+		}),
+		settings.endpoint ?? `https://${accountId}.r2.cloudflarestorage.com`,
+		bucket,
+	);
+}
+
+function azureSharedKeyAuth(
+	accountName: string,
+	accountKey: string,
+	method: string,
+	path: string,
+	headers: Record<string, string>,
+): string {
+	const contentLength = headers["Content-Length"] || "";
+	const contentType = headers["Content-Type"] || "";
+	const msHeaders = Object.entries(headers)
+		.filter(([key]) => key.toLowerCase().startsWith("x-ms-"))
+		.sort(([a], [b]) => a.toLowerCase().localeCompare(b.toLowerCase()))
+		.map(([key, value]) => `${key.toLowerCase()}:${value}`)
+		.join("\n");
+	const canonicalizedResource = `/${accountName}${path}`;
+	const stringToSign = [
+		method,
+		"",
+		"",
+		contentLength,
+		"",
+		contentType,
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		msHeaders,
+		canonicalizedResource,
+	].join("\n");
+	const key = Buffer.from(accountKey, "base64");
+	const signature = createHmac("sha256", key)
+		.update(stringToSign, "utf8")
+		.digest("base64");
+	return `SharedKey ${accountName}:${signature}`;
+}
+
+function createAzureAdapter(
+	settings: RemoteConfigBlobStoreSettings,
+): RemoteConfigBlobStorageAdapter | undefined {
+	const { accessKeyId, secretAccessKey, bucket } = settings;
+	if (!accessKeyId || !secretAccessKey || !bucket) {
+		return undefined;
+	}
+	const baseUrl =
+		settings.endpoint || `https://${accessKeyId}.blob.core.windows.net`;
+	return {
+		async write(path: string, value: string): Promise<void> {
+			const blobPath = `/${bucket}/${path}`;
+			const date = new Date().toUTCString();
+			const bodyBuffer = Buffer.from(value, "utf8");
+			const headers: Record<string, string> = {
+				"x-ms-date": date,
+				"x-ms-version": "2024-11-04",
+				"x-ms-blob-type": "BlockBlob",
+				"Content-Type": "application/json; charset=utf-8",
+				"Content-Length": bodyBuffer.byteLength.toString(),
+			};
+			headers.Authorization = azureSharedKeyAuth(
+				accessKeyId,
+				secretAccessKey,
+				"PUT",
+				blobPath,
+				headers,
+			);
+
+			const response = await fetch(`${baseUrl}${blobPath}`, {
+				method: "PUT",
+				body: bodyBuffer,
+				headers,
+			});
+			if (!response.ok) {
+				const errorBody = await response.text().catch(() => "");
+				throw new Error(
+					`Failed to write ${path}: ${response.status} ${errorBody}`.trim(),
+				);
+			}
+		},
+	};
+}
+
+export function createRemoteConfigBlobStorageAdapter(
+	settings: RemoteConfigBlobStoreSettings,
+): RemoteConfigBlobStorageAdapter | undefined {
+	if (settings.adapterType === "s3") {
+		return createS3Adapter(settings);
+	}
+	if (settings.adapterType === "r2") {
+		return createR2Adapter(settings);
+	}
+	if (settings.adapterType === "azure") {
+		return createAzureAdapter(settings);
+	}
+	return undefined;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function readRemoteConfigSessionBlobUploadMetadata(
+	row: RemoteConfigSessionMetadataRow | undefined,
+): RemoteConfigSessionBlobUploadMetadata | undefined {
+	const raw = row?.metadata?.[REMOTE_CONFIG_SESSION_BLOB_UPLOAD_METADATA_KEY];
+	if (!isRecord(raw)) {
+		return undefined;
+	}
+	const storage = raw.storage;
+	if (!isRecord(storage)) {
+		return undefined;
+	}
+	const adapterType = storage.adapterType;
+	if (adapterType !== "s3" && adapterType !== "r2" && adapterType !== "azure") {
+		return undefined;
+	}
+	if (typeof storage.bucket !== "string") {
+		return undefined;
+	}
+	return {
+		version: 1,
+		storage: {
+			adapterType,
+			bucket: storage.bucket,
+			region: typeof storage.region === "string" ? storage.region : undefined,
+			endpoint:
+				typeof storage.endpoint === "string" ? storage.endpoint : undefined,
+			accountId:
+				typeof storage.accountId === "string" ? storage.accountId : undefined,
+		},
+		keyPrefix: typeof raw.keyPrefix === "string" ? raw.keyPrefix : undefined,
+		userDistinctId:
+			typeof raw.userDistinctId === "string" ? raw.userDistinctId : undefined,
+	};
+}
+
+function buildBlobObjectKey(
+	sessionId: string,
+	messagesPath: string,
+	metadata: RemoteConfigSessionBlobUploadMetadata,
+): string {
+	const userDistinctId = metadata.userDistinctId?.trim() || "unknown";
+	const parts = [
+		"sessions",
+		userDistinctId,
+		sessionId,
+		messagesPath?.endsWith("messages.json")
+			? "messages.json"
+			: basename(messagesPath),
+	].filter((value): value is string => Boolean(value?.trim()));
+	return parts.join("/");
+}
+
+export function createRemoteConfigSessionMessagesArtifactUploader(): RemoteConfigSessionMessagesArtifactUploader {
+	const adapters = new Map<string, RemoteConfigBlobStorageAdapter>();
+	return {
+		async uploadMessagesFile({
+			sessionId,
+			path,
+			contents,
+			row,
+		}): Promise<void> {
+			const metadata = readRemoteConfigSessionBlobUploadMetadata(row);
+			if (!metadata) {
+				return;
+			}
+			const settings = sessionBlobStoreSettings.get(sessionId);
+			if (!settings) {
+				return;
+			}
+			const cacheKey = JSON.stringify(settings);
+			let adapter = adapters.get(cacheKey);
+			if (!adapter) {
+				adapter = createRemoteConfigBlobStorageAdapter(settings);
+				if (!adapter) {
+					return;
+				}
+				adapters.set(cacheKey, adapter);
+			}
+			await adapter.write(
+				buildBlobObjectKey(sessionId, path, metadata),
+				contents,
+			);
+		},
+	};
+}

codna/agent-core/vendor/cline/sdk/packages/shared/src/remote-config/bundle.ts

@@ -0,0 +1,181 @@
+import type { AgentExtension } from "../agents/types";
+import type { BasicLogger } from "../logging/logger";
+import type { OpenTelemetryClientConfig } from "../services/telemetry";
+import type { GlobalInstructionsFile, RemoteConfig } from "./schema";
+
+export interface RemoteConfigIdentityClaims {
+	subject: string;
+	email?: string;
+	roles?: string[];
+	groups?: string[];
+	organizationId?: string;
+	projectIds?: string[];
+	rawClaims?: Record<string, unknown>;
+}
+
+export type RemoteConfigManagedInstructionKind = "rule" | "workflow" | "skill";
+
+export interface RemoteConfigManagedInstructionFile {
+	id: string;
+	name: string;
+	kind: RemoteConfigManagedInstructionKind;
+	contents: string;
+	alwaysEnabled?: boolean;
+	description?: string;
+	metadata?: Record<string, unknown>;
+}
+
+export interface RemoteConfigBundle {
+	source: string;
+	version: string;
+	remoteConfig?: RemoteConfig;
+	managedInstructions?: RemoteConfigManagedInstructionFile[];
+	telemetry?: Record<string, unknown>;
+	claims?: RemoteConfigIdentityClaims;
+	metadata?: Record<string, unknown>;
+}
+
+export interface RemoteConfigProjectContext {
+	projectId?: string;
+	workspaceId?: string;
+	organizationId?: string;
+}
+
+export interface RemoteConfigSyncContext {
+	workspacePath: string;
+	rootPath?: string;
+	context?: RemoteConfigProjectContext;
+	logger?: BasicLogger;
+	signal?: AbortSignal;
+	now?: number;
+}
+
+export interface RemoteConfigControlPlaneFetchInput
+	extends RemoteConfigSyncContext {}
+
+export interface RemoteConfigControlPlane {
+	name: string;
+	fetchBundle(
+		input: RemoteConfigControlPlaneFetchInput,
+	): Promise<RemoteConfigBundle | undefined>;
+}
+
+export interface RemoteConfigBundleStore {
+	read(): Promise<RemoteConfigBundle | undefined>;
+	write(bundle: RemoteConfigBundle): Promise<void>;
+	clear(): Promise<void>;
+}
+
+export interface RemoteConfigManagedArtifactStore {
+	writeText(filePath: string, contents: string): Promise<void>;
+	remove(targetPath: string): Promise<void>;
+	removeChildren(directoryPath: string): Promise<void>;
+}
+
+export interface RemoteConfigManagedPaths {
+	pluginName: string;
+	pluginPath: string;
+	workflowsPath: string;
+	skillsPath: string;
+	bundleCachePath: string;
+	manifestPath: string;
+	rulesFilePath: string;
+}
+
+export interface RemoteConfigMaterializationInput {
+	bundle: RemoteConfigBundle;
+	paths: RemoteConfigManagedPaths;
+	artifactStore: RemoteConfigManagedArtifactStore;
+}
+
+export interface RemoteConfigMaterializedInstructionFile {
+	kind: RemoteConfigManagedInstructionKind;
+	filePath: string;
+	id: string;
+	name: string;
+}
+
+export interface RemoteConfigMaterializationResult {
+	paths: RemoteConfigManagedPaths;
+	rulesFilePath?: string;
+	files: RemoteConfigMaterializedInstructionFile[];
+}
+
+export interface RemoteConfigPolicyMaterializer {
+	materialize(
+		input: RemoteConfigMaterializationInput,
+	): Promise<RemoteConfigMaterializationResult>;
+}
+
+export interface RemoteConfigTelemetryAdapter {
+	name: string;
+	resolveTelemetry(
+		bundle: RemoteConfigBundle,
+		context: RemoteConfigSyncContext,
+	):
+		| Promise<Partial<OpenTelemetryClientConfig> | undefined>
+		| Partial<OpenTelemetryClientConfig>
+		| undefined;
+}
+
+export interface RemoteConfigClaimsMapper<TRole extends string = string> {
+	mapClaimsToRoles(claims: RemoteConfigIdentityClaims): TRole[];
+}
+
+export interface RemoteConfigSyncServiceOptions {
+	controlPlane: RemoteConfigControlPlane;
+	bundleStore: RemoteConfigBundleStore;
+	materializer: RemoteConfigPolicyMaterializer;
+	artifactStore: RemoteConfigManagedArtifactStore;
+	telemetryAdapter?: RemoteConfigTelemetryAdapter;
+	claimsMapper?: RemoteConfigClaimsMapper;
+	logger?: BasicLogger;
+}
+
+export interface RemoteConfigSyncResult {
+	bundle: RemoteConfigBundle;
+	materialized: RemoteConfigMaterializationResult;
+	telemetry?: Partial<OpenTelemetryClientConfig>;
+	roles: string[];
+	claims?: RemoteConfigIdentityClaims;
+}
+
+export interface PrepareRemoteConfigRuntimeOptions
+	extends RemoteConfigSyncContext {
+	pluginName?: string;
+	controlPlane?: RemoteConfigControlPlane;
+	bundleStore?: RemoteConfigBundleStore;
+	artifactStore?: RemoteConfigManagedArtifactStore;
+	materializer?: RemoteConfigPolicyMaterializer;
+	telemetryAdapter?: RemoteConfigTelemetryAdapter;
+	claimsMapper?: RemoteConfigClaimsMapper;
+	useCachedBundle?: boolean;
+	requireBundle?: boolean;
+}
+
+export interface PreparedRemoteConfigRuntime {
+	pluginName: string;
+	pluginDefinition: AgentExtension;
+	paths: RemoteConfigManagedPaths;
+	bundle?: RemoteConfigBundle;
+	telemetry?: Partial<OpenTelemetryClientConfig>;
+	roles: string[];
+	claims?: RemoteConfigIdentityClaims;
+	usedCachedBundle: boolean;
+	workflowsDirectories: readonly string[];
+	skillsDirectories: readonly string[];
+}
+
+export function remoteConfigInstructionToManagedFile(
+	kind: Extract<RemoteConfigManagedInstructionKind, "rule" | "workflow">,
+	file: GlobalInstructionsFile,
+	suffix: string,
+): RemoteConfigManagedInstructionFile {
+	return {
+		id: `remote-config:${kind}:${suffix}:${file.name}`,
+		name: file.name,
+		kind,
+		contents: file.contents,
+		alwaysEnabled: file.alwaysEnabled,
+	};
+}

codna/agent-core/vendor/cline/sdk/packages/shared/src/remote-config/constants.ts

@@ -0,0 +1,5 @@
+/**
+ * URI scheme for opening remote rules/workflows in the editor.
+ * Used to construct URIs like: remote://rule/{name} or remote://workflow/{name}
+ */
+export const REMOTE_URI_SCHEME = "remote://";

codna/agent-core/vendor/cline/sdk/packages/shared/src/remote-config/index.ts

@@ -0,0 +1,9 @@
+export * from "./artifact-store";
+export * from "./blob-storage";
+export * from "./bundle";
+export * from "./constants";
+export * from "./materializer";
+export * from "./paths";
+export * from "./runtime";
+export * from "./schema";
+export * from "./telemetry";