@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

package/vscode/src/vs/platform/agentHost/common/agentHostManagedSettings.js

@@ -0,0 +1,161 @@
+
+import { AgentNetworkDomainSettingId } from '../../networkFilter/common/settings.js';
+import { normalizeDomainPattern } from '../../networkFilter/common/domainMatcher.js';
+import { buildManagedFamilyRule, ManagedRuleFamily, buildManagedRule } from './agentHostManagedRules.js';
+import { inspectValue, getGlobalConfigurationValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostConfigurationSync';
+import { GLOBAL_AUTO_APPROVE_SETTING_ID, ELIGIBLE_FOR_AUTO_APPROVAL_SETTING_ID, TERMINAL_AUTO_APPROVE_ENABLED_SETTING_ID, TERMINAL_AUTO_APPROVE_SETTING_ID } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema';
+
+const AgentHostMapLegacySettingsToManagedSettingsSettingId = "chat.agentHost.copilot.mapLegacySettingsToManagedSettings";
+function managedPermissionsSetting(settingId, sources, transform) {
+    return {
+        settingId,
+        contribute: configurationService => {
+            const configuration = inspectValue(configurationService, settingId);
+            if (configuration === undefined) {
+                return undefined;
+            }
+            const [value, source] = configuration;
+            if (sources === "policyOnly" && source !== "policyValue") {
+                return undefined;
+            }
+            return transform(value);
+        }
+    };
+}
+function managedPermissionsCompositeSetting(settingId, additionalSettingIds, contribute) {
+    return {
+        settingId,
+        additionalSettingIds,
+        contribute
+    };
+}
+function contributeNetworkDomainRules(configurationService) {
+    if (getGlobalConfigurationValue(configurationService, AgentNetworkDomainSettingId.NetworkFilter) !== true) {
+        return undefined;
+    }
+    const allowed = getGlobalConfigurationValue(configurationService, AgentNetworkDomainSettingId.AllowedNetworkDomains) ?? [];
+    const denied = getGlobalConfigurationValue(configurationService, AgentNetworkDomainSettingId.DeniedNetworkDomains) ?? [];
+    if (allowed.length === 0 && denied.length === 0) {
+        return {
+            deny: [buildManagedFamilyRule(ManagedRuleFamily.Domain)]
+        };
+    }
+    const deny = [];
+    for (const pattern of denied) {
+        if (typeof pattern !== "string") {
+            continue;
+        }
+        const domain = normalizeDomainPattern(pattern);
+        if (!domain) {
+            continue;
+        }
+        const rule = domain === "*" ? buildManagedFamilyRule(ManagedRuleFamily.Domain) : buildManagedRule(ManagedRuleFamily.Domain, domain);
+        if (rule) {
+            deny.push(rule);
+        }
+    }
+    return deny.length > 0 ? {
+        deny
+    } : undefined;
+}
+function contributeTerminalDenialRules(rules) {
+    if (!rules || typeof rules !== "object") {
+        return undefined;
+    }
+    const ask = [];
+    for (const [command, value] of Object.entries(rules)) {
+        if (!isSubCommandDenial(value) || !isLiteralCommandKey(command)) {
+            continue;
+        }
+        const rule = buildManagedRule(ManagedRuleFamily.Shell, command);
+        if (rule) {
+            ask.push(rule);
+        }
+    }
+    return ask.length > 0 ? {
+        ask
+    } : undefined;
+}
+function isSubCommandDenial(value) {
+    if (value === false) {
+        return true;
+    }
+    return typeof value === "object" && value !== null && value.approve === false && value.matchCommandLine !== true;
+}
+const AUTO_APPROVE_REGEX_KEY = /^\/.+\/[dgimsuvy]*$/;
+function isLiteralCommandKey(command) {
+    return !AUTO_APPROVE_REGEX_KEY.test(command) && !command.includes("*");
+}
+function contributeEligibleForAutoApprovalRestriction(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    if (( Object.values(value)).every(eligible => eligible === true)) {
+        return undefined;
+    }
+    return {
+        disableBypassPermissionsMode: "disable"
+    };
+}
+const managedPermissionsSettings = [
+    managedPermissionsSetting(GLOBAL_AUTO_APPROVE_SETTING_ID, "policyOnly", value => value === false ? {
+        disableBypassPermissionsMode: "disable"
+    } : undefined),
+    managedPermissionsSetting(
+        ELIGIBLE_FOR_AUTO_APPROVAL_SETTING_ID,
+        "policyOnly",
+        contributeEligibleForAutoApprovalRestriction
+    ),
+    managedPermissionsSetting(
+        TERMINAL_AUTO_APPROVE_ENABLED_SETTING_ID,
+        "anyGlobal",
+        value => value === false ? {
+            ask: [buildManagedFamilyRule(ManagedRuleFamily.Shell)]
+        } : undefined
+    ),
+    managedPermissionsCompositeSetting(AgentNetworkDomainSettingId.NetworkFilter, [
+        AgentNetworkDomainSettingId.AllowedNetworkDomains,
+        AgentNetworkDomainSettingId.DeniedNetworkDomains
+    ], contributeNetworkDomainRules),
+    managedPermissionsSetting(
+        TERMINAL_AUTO_APPROVE_SETTING_ID,
+        "anyGlobal",
+        contributeTerminalDenialRules
+    )
+];
+const managedPermissionsConfigurationIds = [
+    AgentHostMapLegacySettingsToManagedSettingsSettingId,
+    ...managedPermissionsSettings.flatMap(mapping => [mapping.settingId, ...(mapping.additionalSettingIds ?? [])])
+];
+function resolveManagedSettingsPermissions(configurationService) {
+    if (getGlobalConfigurationValue(configurationService, AgentHostMapLegacySettingsToManagedSettingsSettingId) !== true) {
+        return {};
+    }
+    const deny = ( new Set());
+    const ask = ( new Set());
+    let disableBypassPermissionsMode;
+    for (const mapping of managedPermissionsSettings) {
+        const contribution = mapping.contribute(configurationService);
+        if (!contribution) {
+            continue;
+        }
+        if (contribution.disableBypassPermissionsMode) {
+            disableBypassPermissionsMode = contribution.disableBypassPermissionsMode;
+        }
+        contribution.deny?.forEach(rule => deny.add(rule));
+        contribution.ask?.forEach(rule => ask.add(rule));
+    }
+    const permissions = {};
+    if (disableBypassPermissionsMode) {
+        permissions.disableBypassPermissionsMode = disableBypassPermissionsMode;
+    }
+    if (deny.size > 0) {
+        permissions.deny = [...deny];
+    }
+    if (ask.size > 0) {
+        permissions.ask = [...ask];
+    }
+    return permissions;
+}
+
+export { AgentHostMapLegacySettingsToManagedSettingsSettingId, managedPermissionsConfigurationIds, resolveManagedSettingsPermissions };