Sync/vscode 1.118.1

.cortexide/rules/cortexide-standards.md

@@ -0,0 +1,38 @@
+# CortexIDE Engineering Standards
+
+This file is auto-injected into every CortexIDE agent session for this workspace.
+Rules defined here take precedence over the agent's default preferences.
+
+## Code Quality
+
+- **TypeScript strict mode** is mandatory. Never use `any` or `unknown` without explicit narrowing.
+- All `catch` blocks must re-throw, fire an error event, or surface a user notification. Silent swallowing is a bug.
+- No hardcoded hex colors in React components — use `var(--cortex-*, fallback)` CSS custom properties.
+
+## Architecture Layers
+
+This codebase has three strictly enforced layers:
+- `common/` — platform-agnostic. No DOM, no Node, no Electron APIs.
+- `browser/` — DOM + VS Code browser APIs. No Node.
+- `electron-main/` — Node + Electron only. No DOM.
+
+Never import `browser/` from `common/`, or `electron-main/` from `browser/`.
+
+## Security Rules
+
+- All child processes must be spawned via `spawn(command, argsArray)` — never via string interpolation.
+- Never log, telemetry, or transmit API keys. Route all credentials through `ICortexideSettingsService`.
+- Run `secretDetectionService.scan()` on all user content before it reaches an LLM provider.
+
+## Testing
+
+- Every new `IService` needs at least one unit test.
+- New IPC channels need integration smoke tests.
+
+## PR Checklist
+
+Before every PR:
+1. `npm run buildreact` — zero errors
+2. `npx tsc --noEmit --skipLibCheck` — zero errors  
+3. No hardcoded colors, no `console.log` debug statements
+4. No `@ts-ignore` without explanation comment

.devcontainer/devcontainer-lock.json

@@ -1,14 +1,14 @@
 {
   "features": {
-    "ghcr.io/devcontainers/features/desktop-lite:1": {
-      "version": "1.0.8",
-      "resolved": "ghcr.io/devcontainers/features/desktop-lite@sha256:e7dc4d37ab9e3d6e7ebb221bac741f5bfe07dae47025399d038b17af2ed8ddb7",
-      "integrity": "sha256:e7dc4d37ab9e3d6e7ebb221bac741f5bfe07dae47025399d038b17af2ed8ddb7"
+    "ghcr.io/devcontainers/features/desktop-lite:": {
+      "version": "1.2.8",
+      "resolved": "ghcr.io/devcontainers/features/desktop-lite@sha256:14ac23fd59afab939e6562ba6a1f42a659a805e4c574a1be23b06f28eb3b0b71",
+      "integrity": "sha256:14ac23fd59afab939e6562ba6a1f42a659a805e4c574a1be23b06f28eb3b0b71"
     },
-    "ghcr.io/devcontainers/features/rust:1": {
-      "version": "1.3.3",
-      "resolved": "ghcr.io/devcontainers/features/rust@sha256:2521a8eeb4911bfcb22557c8394870ea22eb790d8e52219ddc5182f62d388995",
-      "integrity": "sha256:2521a8eeb4911bfcb22557c8394870ea22eb790d8e52219ddc5182f62d388995"
+    "ghcr.io/devcontainers/features/rust:": {
+      "version": "1.5.0",
+      "resolved": "ghcr.io/devcontainers/features/rust@sha256:0c55e65f2e3df736e478f26ee4d5ed41bae6b54dac1318c443e31444c8ed283c",
+      "integrity": "sha256:0c55e65f2e3df736e478f26ee4d5ed41bae6b54dac1318c443e31444c8ed283c"
     }
   }
 }

.devcontainer/devcontainer.json

@@ -4,8 +4,8 @@
 		"dockerfile": "Dockerfile"
 	},
 	"features": {
-		"ghcr.io/devcontainers/features/desktop-lite:1": {},
-		"ghcr.io/devcontainers/features/rust:1": {}
+		"ghcr.io/devcontainers/features/desktop-lite:": {},
+		"ghcr.io/devcontainers/features/rust:": {}
 	},
 	"containerEnv": {
 		"DISPLAY": "" // Allow the Dev Containers extension to set DISPLAY, post-create.sh will add it back in ~/.bashrc and ~/.zshrc if not set.

.eslint-ignore

@@ -3,6 +3,7 @@
 **/extensions/**/*.d.ts
 **/extensions/**/build/**
 **/extensions/**/colorize-fixtures/**
+**/extensions/copilot/**
 **/extensions/css-language-features/server/test/pathCompletionFixtures/**
 **/extensions/html-language-features/server/lib/jquery.d.ts
 **/extensions/html-language-features/server/src/test/pathCompletionFixtures/**
@@ -18,8 +19,6 @@
 **/extensions/terminal-suggest/src/shell/fishBuiltinsCache.ts
 **/extensions/terminal-suggest/third_party/**
 **/extensions/typescript-language-features/test-workspace/**
-**/extensions/typescript-language-features/extension.webpack.config.js
-**/extensions/typescript-language-features/extension-browser.webpack.config.js
 **/extensions/typescript-language-features/package-manager/node-maintainer/**
 **/extensions/vscode-api-tests/testWorkspace/**
 **/extensions/vscode-api-tests/testWorkspace2/**
@@ -33,7 +32,6 @@
 **/src/typings/**/*.d.ts
 **/src/vs/*/**/*.d.ts
 **/src/vs/base/test/common/filters.perf.data.js
-**/src/vs/loader.js
 **/test/unit/assert.js
 **/test/automation/out/**
 **/typings/**

.eslint-plugin-local/code-amd-node-module.ts

@@ -4,10 +4,12 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as eslint from 'eslint';
+import type * as ESTree from 'estree';
+import { readFileSync } from 'fs';
 import { join } from 'path';
 
 
-export = new class ApiProviderNaming implements eslint.Rule.RuleModule {
+export default new class ApiProviderNaming implements eslint.Rule.RuleModule {
 
 	readonly meta: eslint.Rule.RuleMetaData = {
 		messages: {
@@ -21,7 +23,8 @@ export = new class ApiProviderNaming implements eslint.Rule.RuleModule {
 		const modules = new Set<string>();
 
 		try {
-			const { dependencies, optionalDependencies } = require(join(__dirname, '../package.json'));
+			const packageJson = JSON.parse(readFileSync(join(import.meta.dirname, '../package.json'), 'utf-8'));
+			const { dependencies, optionalDependencies } = packageJson;
 			const all = Object.keys(dependencies).concat(Object.keys(optionalDependencies));
 			for (const key of all) {
 				modules.add(key);
@@ -33,13 +36,13 @@ export = new class ApiProviderNaming implements eslint.Rule.RuleModule {
 		}
 
 
-		const checkImport = (node: any) => {
+		const checkImport = (node: ESTree.Literal & { parent?: ESTree.Node & { importKind?: string } }) => {
 
-			if (node.type !== 'Literal' || typeof node.value !== 'string') {
+			if (typeof node.value !== 'string') {
 				return;
 			}
 
-			if (node.parent.importKind === 'type') {
+			if (node.parent?.type === 'ImportDeclaration' && node.parent.importKind === 'type') {
 				return;
 			}
 

.eslint-plugin-local/code-declare-service-brand.ts

@@ -4,8 +4,9 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as eslint from 'eslint';
+import type * as ESTree from 'estree';
 
-export = new class DeclareServiceBrand implements eslint.Rule.RuleModule {
+export default new class DeclareServiceBrand implements eslint.Rule.RuleModule {
 
 	readonly meta: eslint.Rule.RuleMetaData = {
 		fixable: 'code',
@@ -14,7 +15,7 @@ export = new class DeclareServiceBrand implements eslint.Rule.RuleModule {
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
 		return {
-			['PropertyDefinition[key.name="_serviceBrand"][value]']: (node: any) => {
+			['PropertyDefinition[key.name="_serviceBrand"][value]']: (node: ESTree.PropertyDefinition) => {
 				return context.report({
 					node,
 					message: `The '_serviceBrand'-property should not have a value`,

.eslint-plugin-local/code-ensure-no-disposables-leak-in-test.ts

@@ -4,9 +4,9 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as eslint from 'eslint';
-import { Node } from 'estree';
+import type * as estree from 'estree';
 
-export = new class EnsureNoDisposablesAreLeakedInTestSuite implements eslint.Rule.RuleModule {
+export default new class EnsureNoDisposablesAreLeakedInTestSuite implements eslint.Rule.RuleModule {
 
 	readonly meta: eslint.Rule.RuleMetaData = {
 		type: 'problem',
@@ -18,15 +18,15 @@ export = new class EnsureNoDisposablesAreLeakedInTestSuite implements eslint.Rul
 	};
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
-		const config = <{ exclude: string[] }>context.options[0];
+		const config = context.options[0] as { exclude: string[] };
 
 		const needle = context.getFilename().replace(/\\/g, '/');
 		if (config.exclude.some((e) => needle.endsWith(e))) {
 			return {};
 		}
 
 		return {
-			[`Program > ExpressionStatement > CallExpression[callee.name='suite']`]: (node: Node) => {
+			[`Program > ExpressionStatement > CallExpression[callee.name='suite']`]: (node: estree.Node) => {
 				const src = context.getSourceCode().getText(node);
 				if (!src.includes('ensureNoDisposablesAreLeakedInTestSuite(')) {
 					context.report({

.eslint-plugin-local/code-import-patterns.ts

@@ -7,9 +7,9 @@ import * as eslint from 'eslint';
 import { TSESTree } from '@typescript-eslint/utils';
 import * as path from 'path';
 import minimatch from 'minimatch';
-import { createImportRuleListener } from './utils';
+import { createImportRuleListener } from './utils.ts';
 
-const REPO_ROOT = path.normalize(path.join(__dirname, '../'));
+const REPO_ROOT = path.normalize(path.join(import.meta.dirname, '../'));
 
 interface ConditionalPattern {
 	when?: 'hasBrowser' | 'hasNode' | 'hasElectron' | 'test';
@@ -31,15 +31,15 @@ interface LayerAllowRule {
 type RawOption = RawImportPatternsConfig | LayerAllowRule;
 
 function isLayerAllowRule(option: RawOption): option is LayerAllowRule {
-	return !!((<LayerAllowRule>option).when && (<LayerAllowRule>option).allow);
+	return !!((option as LayerAllowRule).when && (option as LayerAllowRule).allow);
 }
 
 interface ImportPatternsConfig {
 	target: string;
 	restrictions: string[];
 }
 
-export = new class implements eslint.Rule.RuleModule {
+export default new class implements eslint.Rule.RuleModule {
 
 	readonly meta: eslint.Rule.RuleMetaData = {
 		messages: {
@@ -55,7 +55,7 @@ export = new class implements eslint.Rule.RuleModule {
 	};
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
-		const options = <RawOption[]>context.options;
+		const options = context.options as RawOption[];
 		const configs = this._processOptions(options);
 		const relativeFilename = getRelativeFilename(context);
 
@@ -217,7 +217,7 @@ export = new class implements eslint.Rule.RuleModule {
 					configs.push(testConfig);
 				}
 			} else {
-				configs.push({ target, restrictions: <string[]>restrictions.filter(r => typeof r === 'string') });
+				configs.push({ target, restrictions: restrictions.filter(r => typeof r === 'string') as string[] });
 			}
 		}
 		this._optionsCache.set(options, configs);

.eslint-plugin-local/code-layering.ts

@@ -5,14 +5,14 @@
 
 import * as eslint from 'eslint';
 import { join, dirname } from 'path';
-import { createImportRuleListener } from './utils';
+import { createImportRuleListener } from './utils.ts';
 
 type Config = {
 	allowed: Set<string>;
 	disallowed: Set<string>;
 };
 
-export = new class implements eslint.Rule.RuleModule {
+export default new class implements eslint.Rule.RuleModule {
 
 	readonly meta: eslint.Rule.RuleMetaData = {
 		messages: {
@@ -38,8 +38,7 @@ export = new class implements eslint.Rule.RuleModule {
 
 		const fileDirname = dirname(context.getFilename());
 		const parts = fileDirname.split(/\\|\//);
-		const ruleArgs = <Record<string, string[]>>context.options[0];
-
+		const ruleArgs = context.options[0] as Record<string, string[]>;
 		let config: Config | undefined;
 		for (let i = parts.length - 1; i >= 0; i--) {
 			if (ruleArgs[parts[i]]) {
@@ -91,4 +90,3 @@ export = new class implements eslint.Rule.RuleModule {
 		});
 	}
 };
-

.eslint-plugin-local/code-limited-top-functions.ts

@@ -6,8 +6,9 @@
 import * as eslint from 'eslint';
 import { dirname, relative } from 'path';
 import minimatch from 'minimatch';
+import type * as ESTree from 'estree';
 
-export = new class implements eslint.Rule.RuleModule {
+export default new class implements eslint.Rule.RuleModule {
 
 	readonly meta: eslint.Rule.RuleMetaData = {
 		messages: {
@@ -28,11 +29,11 @@ export = new class implements eslint.Rule.RuleModule {
 	};
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
-		let fileRelativePath = relative(dirname(__dirname), context.getFilename());
+		let fileRelativePath = relative(dirname(import.meta.dirname), context.getFilename());
 		if (!fileRelativePath.endsWith('/')) {
 			fileRelativePath += '/';
 		}
-		const ruleArgs = <Record<string, string[]>>context.options[0];
+		const ruleArgs = context.options[0] as Record<string, string[]>;
 
 		const matchingKey = Object.keys(ruleArgs).find(key => fileRelativePath.startsWith(key) || minimatch(fileRelativePath, key));
 		if (!matchingKey) {
@@ -43,8 +44,8 @@ export = new class implements eslint.Rule.RuleModule {
 		const restrictedFunctions = ruleArgs[matchingKey];
 
 		return {
-			FunctionDeclaration: (node: any) => {
-				const isTopLevel = node.parent.type === 'Program';
+			FunctionDeclaration: (node: ESTree.FunctionDeclaration & { parent?: ESTree.Node }) => {
+				const isTopLevel = node.parent?.type === 'Program';
 				const functionName = node.id.name;
 				if (isTopLevel && !restrictedFunctions.includes(node.id.name)) {
 					context.report({
@@ -53,10 +54,10 @@ export = new class implements eslint.Rule.RuleModule {
 					});
 				}
 			},
-			ExportNamedDeclaration(node: any) {
+			ExportNamedDeclaration(node: ESTree.ExportNamedDeclaration & { parent?: ESTree.Node }) {
 				if (node.declaration && node.declaration.type === 'FunctionDeclaration') {
 					const functionName = node.declaration.id.name;
-					const isTopLevel = node.parent.type === 'Program';
+					const isTopLevel = node.parent?.type === 'Program';
 					if (isTopLevel && !restrictedFunctions.includes(node.declaration.id.name)) {
 						context.report({
 							node,

.eslint-plugin-local/code-must-use-result.ts

@@ -4,29 +4,30 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as eslint from 'eslint';
+import type * as ESTree from 'estree';
 import { TSESTree } from '@typescript-eslint/utils';
 
 const VALID_USES = new Set<TSESTree.AST_NODE_TYPES | undefined>([
 	TSESTree.AST_NODE_TYPES.AwaitExpression,
 	TSESTree.AST_NODE_TYPES.VariableDeclarator,
 ]);
 
-export = new class MustUseResults implements eslint.Rule.RuleModule {
+export default new class MustUseResults implements eslint.Rule.RuleModule {
 	readonly meta: eslint.Rule.RuleMetaData = {
 		schema: false
 	};
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
 
-		const config = <{ message: string; functions: string[] }[]>context.options[0];
+		const config = context.options[0] as { message: string; functions: string[] }[];
 		const listener: eslint.Rule.RuleListener = {};
 
 		for (const { message, functions } of config) {
 			for (const fn of functions) {
 				const query = `CallExpression[callee.property.name='${fn}'], CallExpression[callee.name='${fn}']`;
-				listener[query] = (node: any) => {
-					const cast: TSESTree.CallExpression = node;
-					if (!VALID_USES.has(cast.parent?.type)) {
+				listener[query] = (node: ESTree.Node) => {
+					const callExpression = node as TSESTree.CallExpression;
+					if (!VALID_USES.has(callExpression.parent?.type)) {
 						context.report({ node, message });
 					}
 				};

.eslint-plugin-local/code-must-use-super-dispose.ts

@@ -3,18 +3,20 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import { TSESTree } from '@typescript-eslint/utils';
 import * as eslint from 'eslint';
+import type * as ESTree from 'estree';
 
-export = new class NoAsyncSuite implements eslint.Rule.RuleModule {
+export default new class NoAsyncSuite implements eslint.Rule.RuleModule {
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
-		function doesCallSuperDispose(node: any) {
+		function doesCallSuperDispose(node: TSESTree.MethodDefinition) {
 
 			if (!node.override) {
 				return;
 			}
 
-			const body = context.getSourceCode().getText(node);
+			const body = context.getSourceCode().getText(node as ESTree.Node);
 
 			if (body.includes('super.dispose')) {
 				return;