@theia/preferences 1.74.0-next.5 → 1.74.0-next.53

package/src/node/preference-cli-contribution.spec.ts

@@ -0,0 +1,171 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { expect } from 'chai';
+import { OS } from '@theia/core/lib/common/os';
+import { RemoteCliContext } from '@theia/core/lib/node/remote/remote-cli-contribution';
+import { PreferenceCliContribution } from './preference-cli-contribution';
+
+const REMOTE_CLI_CONTEXT: RemoteCliContext = {
+    platform: { os: OS.Type.Linux, arch: 'x64' },
+    directory: '/'
+};
+
+describe('PreferenceCliContribution', () => {
+
+    let contribution: PreferenceCliContribution;
+
+    beforeEach(() => {
+        contribution = new PreferenceCliContribution();
+    });
+
+    describe('--set-preference', () => {
+        it('parses a single key=value entry as JSON', async () => {
+            contribution.setArguments({ setPreference: 'editor.fontSize=14' });
+            expect(await contribution.getPreferences()).to.deep.equal([['editor.fontSize', 14]]);
+            expect(await contribution.getSessionPreferences()).to.deep.equal([]);
+        });
+
+        it('parses string values quoted as JSON strings', async () => {
+            contribution.setArguments({ setPreference: 'workbench.colorTheme="Dark+"' });
+            expect(await contribution.getPreferences()).to.deep.equal([['workbench.colorTheme', 'Dark+']]);
+        });
+
+        it('parses object values', async () => {
+            contribution.setArguments({ setPreference: 'ai-features.chat.toolConfirmation={"shellExecute":"always_allow"}' });
+            expect(await contribution.getPreferences()).to.deep.equal([
+                ['ai-features.chat.toolConfirmation', { shellExecute: 'always_allow' }]
+            ]);
+        });
+
+        it('accepts an array of entries', async () => {
+            contribution.setArguments({ setPreference: ['editor.fontSize=12', 'editor.tabSize=2'] });
+            expect(await contribution.getPreferences()).to.deep.equal([
+                ['editor.fontSize', 12],
+                ['editor.tabSize', 2]
+            ]);
+        });
+
+        it('decodes base64-prefixed JSON values', async () => {
+            const json = JSON.stringify({ nested: true, n: 1 });
+            const b64 = Buffer.from(json, 'utf-8').toString('base64');
+            contribution.setArguments({ setPreference: `my.pref=base64:${b64}` });
+            expect(await contribution.getPreferences()).to.deep.equal([
+                ['my.pref', { nested: true, n: 1 }]
+            ]);
+        });
+
+        it('preserves "=" characters inside the value', async () => {
+            contribution.setArguments({ setPreference: 'my.pref="a=b=c"' });
+            expect(await contribution.getPreferences()).to.deep.equal([['my.pref', 'a=b=c']]);
+        });
+
+        it('skips entries that do not contain "="', async () => {
+            const originalWarn = console.warn;
+            console.warn = () => { /* silence expected warning */ };
+            try {
+                contribution.setArguments({ setPreference: ['justAKey', 'editor.fontSize=14'] });
+            } finally {
+                console.warn = originalWarn;
+            }
+            expect(await contribution.getPreferences()).to.deep.equal([['editor.fontSize', 14]]);
+        });
+
+        it('skips entries whose value is not valid JSON', async () => {
+            const originalWarn = console.warn;
+            console.warn = () => { /* silence expected warning */ };
+            try {
+                contribution.setArguments({ setPreference: ['my.pref=notJson', 'editor.fontSize=14'] });
+            } finally {
+                console.warn = originalWarn;
+            }
+            expect(await contribution.getPreferences()).to.deep.equal([['editor.fontSize', 14]]);
+        });
+    });
+
+    describe('--session-preference', () => {
+        it('routes entries into the session preferences bucket', async () => {
+            contribution.setArguments({ sessionPreference: 'ai-features.chat.defaultToolConfirmation="always_allow"' });
+            expect(await contribution.getSessionPreferences()).to.deep.equal([
+                ['ai-features.chat.defaultToolConfirmation', 'always_allow']
+            ]);
+            expect(await contribution.getPreferences()).to.deep.equal([]);
+        });
+
+        it('supports multiple session entries and base64', async () => {
+            const b64 = Buffer.from('{"shellExecute":"always_allow"}', 'utf-8').toString('base64');
+            contribution.setArguments({
+                sessionPreference: [
+                    'ai-features.chat.defaultToolConfirmation="always_allow"',
+                    `ai-features.chat.toolConfirmation=base64:${b64}`
+                ]
+            });
+            expect(await contribution.getSessionPreferences()).to.deep.equal([
+                ['ai-features.chat.defaultToolConfirmation', 'always_allow'],
+                ['ai-features.chat.toolConfirmation', { shellExecute: 'always_allow' }]
+            ]);
+        });
+
+        it('keeps --set-preference and --session-preference independent', async () => {
+            contribution.setArguments({
+                setPreference: 'editor.fontSize=14',
+                sessionPreference: 'editor.fontSize=20'
+            });
+            expect(await contribution.getPreferences()).to.deep.equal([['editor.fontSize', 14]]);
+            expect(await contribution.getSessionPreferences()).to.deep.equal([['editor.fontSize', 20]]);
+        });
+    });
+
+    describe('enhanceArgs (remote forwarding)', () => {
+        it('returns an empty list when no session prefs are set', () => {
+            expect(contribution.enhanceArgs(REMOTE_CLI_CONTEXT)).to.deep.equal([]);
+        });
+
+        it('emits one base64-encoded --session-preference flag per entry', () => {
+            contribution.setArguments({
+                sessionPreference: [
+                    'ai-features.chat.defaultToolConfirmation="always_allow"',
+                    'ai-features.chat.toolConfirmation={"shellExecute":"always_allow"}'
+                ]
+            });
+            const args = contribution.enhanceArgs(REMOTE_CLI_CONTEXT);
+            expect(args).to.have.lengthOf(2);
+            for (const arg of args) {
+                expect(arg.startsWith('--session-preference=')).to.be.true;
+                const eq = arg.indexOf('=', '--session-preference='.length);
+                const key = arg.substring('--session-preference='.length, eq);
+                const rawValue = arg.substring(eq + 1);
+                expect(rawValue.startsWith('base64:')).to.be.true;
+                const decoded = JSON.parse(Buffer.from(rawValue.substring('base64:'.length), 'base64').toString('utf-8'));
+                if (key === 'ai-features.chat.defaultToolConfirmation') {
+                    expect(decoded).to.equal('always_allow');
+                } else {
+                    expect(decoded).to.deep.equal({ shellExecute: 'always_allow' });
+                }
+            }
+        });
+
+        it('does not forward --set-preference values', () => {
+            contribution.setArguments({
+                setPreference: 'editor.fontSize=14',
+                sessionPreference: 'foo="bar"'
+            });
+            const args = contribution.enhanceArgs(REMOTE_CLI_CONTEXT);
+            expect(args).to.have.lengthOf(1);
+            expect(args[0]).to.match(/^--session-preference=foo=base64:/);
+        });
+    });
+});

package/src/node/preference-cli-contribution.ts

@@ -17,30 +17,52 @@
 import { injectable } from '@theia/core/shared/inversify';
 import { Argv } from '@theia/core/shared/yargs';
 import { CliContribution } from '@theia/core/lib/node/cli';
+import { RemoteCliContext, RemoteCliContribution } from '@theia/core/lib/node/remote/remote-cli-contribution';
 import { CliPreferences } from '../common/cli-preferences';
 
 @injectable()
-export class PreferenceCliContribution implements CliContribution, CliPreferences {
+export class PreferenceCliContribution implements CliContribution, CliPreferences, RemoteCliContribution {
 
     protected preferences: [string, unknown][] = [];
+    protected sessionPreferences: [string, unknown][] = [];
 
     configure(conf: Argv<{}>): void {
         conf.option('set-preference', {
             nargs: 1,
-            desc: 'sets the specified preference'
+            desc: 'sets the specified preference (persisted to user settings)'
+        });
+        conf.option('session-preference', {
+            nargs: 1,
+            desc: 'sets the specified preference for this process only (in-memory, not persisted)'
         });
     }
 
     setArguments(args: Record<string, unknown>): void {
         if (args.setPreference) {
-            const preferences: string[] = args.setPreference instanceof Array ? args.setPreference : [args.setPreference];
-            for (const preference of preferences) {
-                const firstEqualIndex = preference.indexOf('=');
-                let rawValue = preference.substring(firstEqualIndex + 1);
-                if (rawValue.startsWith('base64:')) {
-                    rawValue = Buffer.from(rawValue.substring('base64:'.length), 'base64').toString('utf-8');
-                }
-                this.preferences.push([preference.substring(0, firstEqualIndex), JSON.parse(rawValue)]);
+            this.parseInto(args.setPreference, this.preferences);
+        }
+        if (args.sessionPreference) {
+            this.parseInto(args.sessionPreference, this.sessionPreferences);
+        }
+    }
+
+    protected parseInto(raw: unknown, target: [string, unknown][]): void {
+        const entries: string[] = raw instanceof Array ? raw : [raw as string];
+        for (const entry of entries) {
+            const firstEqualIndex = entry.indexOf('=');
+            if (firstEqualIndex <= 0) {
+                console.warn(`Ignoring preference CLI argument "${entry}": expected KEY=JSONVALUE.`);
+                continue;
+            }
+            let rawValue = entry.substring(firstEqualIndex + 1);
+            if (rawValue.startsWith('base64:')) {
+                rawValue = Buffer.from(rawValue.substring('base64:'.length), 'base64').toString('utf-8');
+            }
+            try {
+                target.push([entry.substring(0, firstEqualIndex), JSON.parse(rawValue)]);
+            } catch (e) {
+                const reason = e instanceof Error ? e.message : String(e);
+                console.warn(`Ignoring preference CLI argument "${entry}": value is not valid JSON (${reason}).`);
             }
         }
     }
@@ -49,4 +71,20 @@ export class PreferenceCliContribution implements CliContribution, CliPreference
         return this.preferences;
     }
 
+    async getSessionPreferences(): Promise<[string, unknown][]> {
+        return this.sessionPreferences;
+    }
+
+    /**
+     * Forward `--session-preference` values to the remote backend when attaching
+     * to a remote (e.g. dev container). Values are base64-encoded JSON to survive
+     * shell argument parsing intact.
+     */
+    enhanceArgs(_context: RemoteCliContext): string[] {
+        return this.sessionPreferences.map(([key, value]) => {
+            const encoded = Buffer.from(JSON.stringify(value), 'utf-8').toString('base64');
+            return `--session-preference=${key}=base64:${encoded}`;
+        });
+    }
+
 }