@codingame/monaco-vscode-api 34.1.3 → 35.0.1

package/vscode/src/vs/platform/agentPlugins/common/pluginParsers.js

@@ -2,18 +2,19 @@
 import '../../../base/common/json.js';
 import { equals, cloneAndChange } from '../../../base/common/objects.js';
 import { isAbsolute } from '../../../base/common/path.js';
-import { untildify } from '../../../base/common/labels.js';
-import { isEqual, joinPath, basename, isEqualOrParent, normalizePath, extname } from '../../../base/common/resources.js';
+import { isEqual, joinPath, basename, isEqualOrParent, normalizePath, extname, dirname } from '../../../base/common/resources.js';
 import { escapeRegExpCharacters } from '../../../base/common/strings.js';
 import '../../../base/common/errors.js';
 import { URI } from '../../../base/common/uri.js';
-import '../../../base/common/yaml.js';
+import { parseFrontMatter } from '../../../base/common/yaml.js';
 import { McpServerType } from '../../mcp/common/mcpPlatformTypes.js';
 import '../../agentHost/common/state/protocol/channels-root/state.js';
 import { CustomizationType, McpServerStatus } from '../../agentHost/common/state/protocol/channels-session/state.js';
+import '../../agentHost/common/state/protocol/channels-chat/state.js';
 import '../../agentHost/common/state/protocol/channels-terminal/state.js';
 import '../../agentHost/common/state/protocol/channels-changeset/state.js';
 import '../../agentHost/common/state/protocol/channels-resource-watch/state.js';
+import { DEFAULT_MCP_APP } from '../../agentHost/common/state/protocol/mcpAppDefaults.js';
 import { customizationId } from '../../agentHost/common/state/sessionState.js';
 
 var IParsedHookCommand;
@@ -115,7 +116,8 @@ function makeMcpServerCustomization(definitionUri, name) {
         enabled: true,
         state: {
             kind: McpServerStatus.Starting
-        }
+        },
+        mcpApp: DEFAULT_MCP_APP
     };
 }
 const emptyComponentPathConfig = {
@@ -362,11 +364,12 @@ function resolveHookCommand(raw, workspaceRoot, userHome) {
     let cwdUri;
     const rawCwd = typeof raw.cwd === "string" ? raw.cwd : undefined;
     if (rawCwd) {
-        const expanded = untildify(rawCwd, userHome);
-        if (isAbsolute(expanded)) {
-            cwdUri = URI.file(expanded);
+        if (rawCwd.startsWith("~/")) {
+            cwdUri = URI.joinPath(userHome, rawCwd.substring(2));
+        } else if (isAbsolute(rawCwd)) {
+            cwdUri = URI.file(rawCwd);
         } else if (workspaceRoot) {
-            cwdUri = joinPath(workspaceRoot, expanded);
+            cwdUri = joinPath(workspaceRoot, rawCwd);
         }
     } else {
         cwdUri = workspaceRoot;
@@ -490,41 +493,51 @@ const COMMAND_FILE_SUFFIX = ".md";
 async function readSkills(pluginRoot, dirs, fileService) {
     const seen = ( new Set());
     const skills = [];
-    const addSkill = (name, skillMd) => {
-        if (!( seen.has(name))) {
-            seen.add(name);
-            skills.push({
-                uri: skillMd,
-                name
-            });
-        }
+    const addSkill = async (name, skillMd) => {
+        let description;
+        try {
+            const parsedInfo = await parseSkillFile(skillMd, fileService);
+            description = parsedInfo.description;
+            name = parsedInfo.name || name;
+        } catch {}
+        if (( seen.has(name))) {
+            return;
+        }
+        seen.add(name);
+        skills.push({
+            uri: skillMd,
+            name,
+            ...(description ? {
+                description
+            } : {})
+        });
     };
-    for (const dir of dirs) {
+    await Promise.all(( dirs.map(async dir => {
         const skillMd = URI.joinPath(dir, "SKILL.md");
         if (await pathExists(skillMd, fileService)) {
-            addSkill(basename(dir), skillMd);
-            continue;
+            await addSkill(basename(dir), skillMd);
+            return;
         }
         let stat;
         try {
             stat = await fileService.resolve(dir);
         } catch {
-            continue;
+            return;
         }
         if (!stat.isDirectory || !stat.children) {
-            continue;
+            return;
         }
-        for (const child of stat.children) {
+        await Promise.all(( stat.children.map(async child => {
             const childSkillMd = URI.joinPath(child.resource, "SKILL.md");
             if (await pathExists(childSkillMd, fileService)) {
-                addSkill(basename(child.resource), childSkillMd);
+                await addSkill(basename(child.resource), childSkillMd);
             }
-        }
-    }
+        })));
+    })));
     if (skills.length === 0) {
         const rootSkillMd = URI.joinPath(pluginRoot, "SKILL.md");
         if (await pathExists(rootSkillMd, fileService)) {
-            addSkill(basename(pluginRoot), rootSkillMd);
+            await addSkill(basename(pluginRoot), rootSkillMd);
         }
     }
     skills.sort((a, b) => a.name.localeCompare(b.name));
@@ -569,6 +582,24 @@ async function readMarkdownComponents(dirs, fileService) {
     items.sort((a, b) => a.name.localeCompare(b.name));
     return items;
 }
+async function parseSkillFile(uri, fileService) {
+    try {
+        const content = await fileService.readFile(uri);
+        const frontmatter = parseFrontMatter(( content.value.toString()));
+        const name = frontmatter?.getStringValue("name")?.trim() || basename(dirname(uri));
+        const description = frontmatter?.getStringValue("description")?.trim();
+        const userInvokable = frontmatter?.getBooleanValue("user-invocable");
+        return {
+            name,
+            description,
+            userInvokable
+        };
+    } catch {
+        return {
+            name: basename(dirname(uri))
+        };
+    }
+}
 function parseMcpServerDefinitionMap(definitionURI, raw, pluginFsPath, formatConfig) {
     const mcpServers = resolveMcpServersMap(raw);
     if (!mcpServers) {
@@ -600,4 +631,4 @@ function parseMcpServerDefinitionMap(definitionURI, raw, pluginFsPath, formatCon
     return definitions;
 }
 
-export { IParsedHookCommand, PluginFormat, convertBareEnvVarsToVsCodeSyntax, detectPluginFormat, interpolateHookPluginRoot, interpolateMcpPluginRoot, normalizeMcpServerConfiguration, parseComponentPathConfig, parseMcpServerDefinitionMap, pathExists, readMarkdownComponents, readSkills, resolveComponentDirs, resolveMcpServersMap, shellQuotePluginRootInCommand };
+export { IParsedHookCommand, PluginFormat, convertBareEnvVarsToVsCodeSyntax, detectPluginFormat, interpolateHookPluginRoot, interpolateMcpPluginRoot, makeMcpServerCustomization, normalizeMcpServerConfiguration, parseComponentPathConfig, parseHooksJson, parseMcpServerDefinitionMap, parseSkillFile, pathExists, readMarkdownComponents, readSkills, resolveComponentDirs, resolveMcpServersMap, shellQuotePluginRootInCommand };

package/vscode/src/vs/platform/browserView/common/browserHistory.js

@@ -62,14 +62,16 @@ class BrowserHistoryEntriesStore extends Disposable {
         const nextTitle = patch.title && patch.title.length > 0 ? patch.title : existing.title;
         const nextUrl = patch.url && patch.url.length > 0 ? patch.url : existing.url;
         const nextFaviconHash = patch.faviconHash === undefined ? existing.icon : (patch.faviconHash ?? undefined);
-        if (nextUrl === existing.url && nextTitle === existing.title && nextFaviconHash === existing.icon) {
+        const nextTime = patch.url ? Date.now() : existing.time;
+        if (nextUrl === existing.url && nextTitle === existing.title && nextFaviconHash === existing.icon && nextTime === existing.time) {
             return false;
         }
         this._items[idx] = {
             ...existing,
             url: nextUrl,
             title: nextTitle,
-            icon: nextFaviconHash
+            icon: nextFaviconHash,
+            time: nextTime
         };
         this._onDidChange.fire();
         return true;

package/vscode/src/vs/platform/browserView/common/browserPermissions.d.ts

@@ -0,0 +1,176 @@
+import { Event } from "../../../base/common/event.js";
+import { Disposable } from "../../../base/common/lifecycle.js";
+import { ThemeIcon } from "../../../base/common/themables.js";
+/**
+ * UI-agnostic, per-origin permission model for the integrated browser, modeled
+ * on Chromium's user-friendly Site Settings categories rather than the raw
+ * Electron permission strings. This module intentionally ships NO UI and no
+ * Electron import so it can load in both the main process (authoritative store)
+ * and the workbench renderer (read mirror hydrated from storage).
+ *
+ * The Electron permission string list is taken from Electron's own source
+ * (`shell/common/gin_converters/content_converter.cc`), the single source of
+ * truth for the strings passed to the permission handlers. Any
+ * `blink::PermissionType` Electron does not explicitly name is reported as
+ * `'unknown'`.
+ */
+/**
+ * A decision a user can record for a (origin, category) pair. These are the
+ * only two values ever persisted; clearing a decision removes it entirely.
+ *   - 'allow' -> grant without prompting
+ *   - 'deny'  -> reject without prompting
+ */
+export type PermissionDecision = "allow" | "deny";
+/**
+ * The effective state of a (origin, category) pair: either a recorded
+ * {@link PermissionDecision}, or 'ask' when no decision has been recorded.
+ * 'ask' is only ever a default/effective value -- it is never stored.
+ */
+export type PermissionState = PermissionDecision | "ask";
+/**
+ * User-facing permission categories. These are deliberately coarser and more
+ * meaningful than Electron's raw permission strings. For example Electron's
+ * single `media` permission is split into `Camera` and `Microphone`, and the
+ * various clipboard permissions collapse into `Clipboard`.
+ */
+export declare enum PermissionCategory {
+    Location = "location",
+    Camera = "camera",
+    Microphone = "microphone",
+    Notifications = "notifications",
+    Sensors = "sensors",
+    Clipboard = "clipboard",
+    Devices = "devices"
+}
+/**
+ * The kinds of hardware-device chooser flows the {@link PermissionCategory.Devices}
+ * category gates. Each maps to a distinct Electron device-selection event but is
+ * surfaced to the user through one unified request/selection flow.
+ */
+export type BrowserDeviceType = "usb" | "serial" | "hid" | "bluetooth";
+/**
+ * A single hardware device offered to the user during a device-chooser flow.
+ * Only plain, user-presentable data crosses the IPC boundary; the opaque
+ * `deviceId` is echoed back verbatim to select the device.
+ */
+export interface IBrowserDeviceCandidate {
+    /** Opaque, device-type-specific identifier echoed back to select the device. */
+    readonly deviceId: string;
+    /** Primary, user-facing label (e.g. product name). */
+    readonly label: string;
+    /** Optional secondary detail (e.g. manufacturer or vendor:product ids). */
+    readonly detail?: string;
+}
+/**
+ * Static metadata describing a category and how it maps to Electron's raw
+ * permission strings. A UI can iterate {@link PERMISSION_CATEGORY_DESCRIPTORS}
+ * to render a settings list directly from this data.
+ */
+export interface IPermissionCategoryDescriptor {
+    readonly category: PermissionCategory;
+    /** Short, human-readable label suitable for a settings row. */
+    readonly label: string;
+    /** One-line description of what granting this category enables. */
+    readonly description: string;
+    /** The icon to display for this category. */
+    readonly icon: ThemeIcon;
+    /** Electron permission strings that map to this category. */
+    readonly permissions: string[];
+    /** State assumed for this category when an origin has not recorded a decision. */
+    readonly defaultState: PermissionState;
+}
+export declare const PERMISSION_CATEGORY_DESCRIPTORS: Readonly<Record<PermissionCategory, IPermissionCategoryDescriptor>>;
+/**
+ * Raw Electron permission strings that are granted unconditionally, with no
+ * recorded state and no management control. These are low-risk capabilities
+ * that Chrome itself also always grants automatically.
+ */
+export declare const ALWAYS_ALLOWED_PERMISSIONS: ReadonlySet<string>;
+/** Whether a raw Electron permission string is granted unconditionally. */
+export declare function isAlwaysAllowedPermission(permission: string): boolean;
+/** All categories, in a stable display order. */
+export declare const ALL_PERMISSION_CATEGORIES: readonly PermissionCategory[];
+/**
+ * Map a raw Electron permission string (from either handler, or a device type)
+ * to the user-friendly category/categories it represents.
+ *
+ * Notes:
+ *   - `media` resolves to `Camera`, `Microphone`, or both depending on the
+ *     normalized `mediaKinds` hint extracted by the caller from Electron's
+ *     details. With no hint it conservatively resolves to both, so the caller
+ *     can require the strictest decision.
+ *   - `unknown` (and anything unrecognized) resolves to an empty array.
+ */
+export declare function electronPermissionToCategories(permission: string, mediaKinds?: ReadonlyArray<"video" | "audio">): PermissionCategory[];
+/**
+ * Normalize a full URL down to a stable permission key.
+ *
+ * For URLs with a real origin (http/https/etc.) this returns the origin
+ * (scheme + host + port), e.g. "https://example.com:8443". Host-less URLs such
+ * as `file:` have no meaningful origin, so they key off the scheme and full
+ * path instead (query and fragment removed), e.g. "file:///home/user/page.html".
+ * Falls back to the trimmed raw input if it cannot be parsed.
+ */
+export declare function toOriginKey(url: string | undefined | null): string;
+/** A single recorded grant: which origin, which category, what decision. */
+export interface IPermissionGrant {
+    readonly origin: string;
+    readonly category: PermissionCategory;
+    readonly state: PermissionDecision;
+}
+/**
+ * A (category, decision) pair for one (implied) origin; the write API payload.
+ * A `null` decision clears any recorded choice, falling back to the default.
+ */
+export interface IPermissionCategoryState {
+    readonly category: PermissionCategory;
+    readonly state: PermissionDecision | null;
+}
+/**
+ * On-disk shape of the whole store: `{ origin: { category: decision } }`.
+ */
+export interface ISerializedBrowserPermissionsSnapshot {
+    readonly origins: Readonly<Record<string, Partial<Record<PermissionCategory, PermissionDecision>>>>;
+}
+/**
+ * In-memory, serializable tracker of permission state keyed by (origin,
+ * category). The main process owns the authoritative instance; the workbench
+ * keeps a read mirror hydrated from storage. Mutate with `set` / `setMany`,
+ * observe with `onDidChange`, persist with `serialize` / `hydrate`.
+ */
+export declare class BrowserPermissionStore extends Disposable {
+    private readonly _data;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<void>;
+    /**
+     * The default state assumed for a category when an origin has recorded no decision.
+     */
+    defaultStateFor(category: PermissionCategory): PermissionState;
+    /** Get the recorded decision for a (origin, category) pair. */
+    getDecision(origin: string, category: PermissionCategory): PermissionDecision | undefined;
+    /**
+     * Resolve the effective boolean decision for a (origin, category) pair,
+     * applying {@link defaultStateFor} when the recorded state is 'ask'.
+     */
+    isAllowed(origin: string, category: PermissionCategory): boolean;
+    /** Set (or clear, via `null`) the decision for a (origin, category) pair. */
+    set(origin: string, category: PermissionCategory, decision: PermissionDecision | null): void;
+    /** Set (or clear) the decision for several categories of one origin at once. */
+    setMany(origin: string, grants: Iterable<IPermissionCategoryState>): void;
+    /** Remove all recorded state for an origin. */
+    clearOrigin(origin: string): void;
+    /** Remove all recorded state for every origin. */
+    clear(): void;
+    /**
+     * Return the full category->state map for one origin, including categories
+     * with no recorded decision. Ideal for rendering a
+     * per-site settings page.
+     */
+    getOrigin(origin: string): Record<PermissionCategory, PermissionState>;
+    /** All origins that have at least one recorded decision. */
+    origins(): string[];
+    /** Flat list of every recorded grant. */
+    list(): IPermissionGrant[];
+    serialize(): ISerializedBrowserPermissionsSnapshot;
+    hydrate(snapshot: ISerializedBrowserPermissionsSnapshot | undefined): void;
+}

package/vscode/src/vs/platform/browserView/common/browserPermissions.js

@@ -0,0 +1,244 @@
+
+import { Codicon } from '../../../base/common/codicons.js';
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { localize } from '../../../nls.js';
+
+var PermissionCategory;
+(function(PermissionCategory) {
+    PermissionCategory["Location"] = "location";
+    PermissionCategory["Camera"] = "camera";
+    PermissionCategory["Microphone"] = "microphone";
+    PermissionCategory["Notifications"] = "notifications";
+    PermissionCategory["Sensors"] = "sensors";
+    PermissionCategory["Clipboard"] = "clipboard";
+    PermissionCategory["Devices"] = "devices";
+})(PermissionCategory || (PermissionCategory = {}));
+const PERMISSION_CATEGORY_DESCRIPTORS = {
+    [PermissionCategory.Location]: {
+        category: PermissionCategory.Location,
+        label: ( localize(1933, "Location")),
+        description: ( localize(1934, "Access this device's geographic location")),
+        icon: Codicon.location,
+        permissions: ["geolocation", "geolocation-approximate"],
+        defaultState: "ask"
+    },
+    [PermissionCategory.Camera]: {
+        category: PermissionCategory.Camera,
+        label: ( localize(1935, "Camera")),
+        description: ( localize(1936, "Capture video from cameras")),
+        icon: Codicon.deviceCamera,
+        permissions: ["media"],
+        defaultState: "ask"
+    },
+    [PermissionCategory.Microphone]: {
+        category: PermissionCategory.Microphone,
+        label: ( localize(1937, "Microphone")),
+        description: ( localize(1938, "Capture audio from microphones")),
+        icon: Codicon.mic,
+        permissions: ["media"],
+        defaultState: "ask"
+    },
+    [PermissionCategory.Sensors]: {
+        category: PermissionCategory.Sensors,
+        label: ( localize(1939, "Sensors")),
+        description: ( localize(1940, "Read motion and environmental sensors")),
+        icon: Codicon.pulse,
+        permissions: ["sensors"],
+        defaultState: "allow"
+    },
+    [PermissionCategory.Clipboard]: {
+        category: PermissionCategory.Clipboard,
+        label: ( localize(1941, "Clipboard")),
+        description: ( localize(1942, "Read from and write to the system clipboard")),
+        icon: Codicon.clippy,
+        permissions: ["clipboard-read"],
+        defaultState: "ask"
+    },
+    [PermissionCategory.Notifications]: {
+        category: PermissionCategory.Notifications,
+        label: ( localize(1943, "Notifications")),
+        description: ( localize(1944, "Display desktop notifications")),
+        icon: Codicon.bell,
+        permissions: ["notifications"],
+        defaultState: "ask"
+    },
+    [PermissionCategory.Devices]: {
+        category: PermissionCategory.Devices,
+        label: ( localize(1945, "Devices")),
+        description: ( localize(1946, "Request access to USB, serial, HID, and Bluetooth devices")),
+        icon: Codicon.plug,
+        permissions: ["usb", "serial", "hid"],
+        defaultState: "allow"
+    }
+};
+const ALL_PERMISSION_CATEGORIES = ( Object.keys(PERMISSION_CATEGORY_DESCRIPTORS));
+const DEFAULT_PERMISSION_STATES = ( Object.freeze(Object.fromEntries(( ALL_PERMISSION_CATEGORIES.map(
+    category => [category, PERMISSION_CATEGORY_DESCRIPTORS[category].defaultState]
+)))));
+(() => {
+    const map = ( new Map());
+    for (const category of ALL_PERMISSION_CATEGORIES) {
+        for (const permission of PERMISSION_CATEGORY_DESCRIPTORS[category].permissions) {
+            if (permission === "media") {
+                continue;
+            }
+            const existing = map.get(permission);
+            if (existing) {
+                existing.push(category);
+            } else {
+                map.set(permission, [category]);
+            }
+        }
+    }
+    return map;
+})();
+function toOriginKey(url) {
+    const trimmed = url?.trim();
+    if (!trimmed || trimmed === "null") {
+        return "";
+    }
+    try {
+        const parsed = ( new URL(trimmed));
+        if (!parsed.host) {
+            return `${parsed.protocol}//${parsed.pathname}`;
+        }
+        return parsed.origin;
+    } catch {
+        return trimmed;
+    }
+}
+const VALID_CATEGORIES = ( new Set(ALL_PERMISSION_CATEGORIES));
+class BrowserPermissionStore extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._data = ( new Map());
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+    }
+    defaultStateFor(category) {
+        return PERMISSION_CATEGORY_DESCRIPTORS[category].defaultState;
+    }
+    getDecision(origin, category) {
+        return this._data.get(toOriginKey(origin))?.get(category);
+    }
+    isAllowed(origin, category) {
+        return (this.getDecision(origin, category) ?? this.defaultStateFor(category)) === "allow";
+    }
+    set(origin, category, decision) {
+        const key = toOriginKey(origin);
+        if (!key) {
+            return;
+        }
+        if (decision === null) {
+            const categories = this._data.get(key);
+            if (!categories?.delete(category)) {
+                return;
+            }
+            if (categories.size === 0) {
+                this._data.delete(key);
+            }
+        } else {
+            let categories = this._data.get(key);
+            if (categories?.get(category) === decision) {
+                return;
+            }
+            if (!categories) {
+                categories = ( new Map());
+                this._data.set(key, categories);
+            }
+            categories.set(category, decision);
+        }
+        this._onDidChange.fire();
+    }
+    setMany(origin, grants) {
+        for (const {
+            category,
+            state
+        } of grants) {
+            this.set(origin, category, state);
+        }
+    }
+    clearOrigin(origin) {
+        const key = toOriginKey(origin);
+        if (this._data.delete(key)) {
+            this._onDidChange.fire();
+        }
+    }
+    clear() {
+        if (this._data.size === 0) {
+            return;
+        }
+        this._data.clear();
+        this._onDidChange.fire();
+    }
+    getOrigin(origin) {
+        const result = {
+            ...DEFAULT_PERMISSION_STATES
+        };
+        const recorded = this._data.get(toOriginKey(origin));
+        if (recorded) {
+            for (const [category, state] of recorded) {
+                result[category] = state;
+            }
+        }
+        return result;
+    }
+    origins() {
+        return [...( this._data.keys())];
+    }
+    list() {
+        const grants = [];
+        for (const [origin, categories] of this._data) {
+            for (const [category, state] of categories) {
+                grants.push({
+                    origin,
+                    category,
+                    state
+                });
+            }
+        }
+        return grants;
+    }
+    serialize() {
+        const origins = {};
+        for (const [origin, categories] of this._data) {
+            const entry = {};
+            for (const [category, state] of categories) {
+                entry[category] = state;
+            }
+            origins[origin] = entry;
+        }
+        return {
+            origins
+        };
+    }
+    hydrate(snapshot) {
+        this._data.clear();
+        if (snapshot?.origins && typeof snapshot.origins === "object") {
+            for (const [origin, categories] of Object.entries(snapshot.origins)) {
+                if (!categories || typeof categories !== "object") {
+                    continue;
+                }
+                const key = toOriginKey(origin);
+                if (!key) {
+                    continue;
+                }
+                let target;
+                for (const [category, state] of Object.entries(categories)) {
+                    if (!( VALID_CATEGORIES.has(category)) || (state !== "allow" && state !== "deny")) {
+                        continue;
+                    }
+                    if (!target) {
+                        target = ( new Map());
+                        this._data.set(key, target);
+                    }
+                    target.set(category, state);
+                }
+            }
+        }
+        this._onDidChange.fire();
+    }
+}
+
+export { ALL_PERMISSION_CATEGORIES, BrowserPermissionStore, PERMISSION_CATEGORY_DESCRIPTORS, PermissionCategory, toOriginKey };