@agentrhq/webcmd 0.4.1 → 0.4.3

package/dist/src/build-manifest.js

@@ -107,7 +107,6 @@ function toManifestEntry(cmd, modulePath, sourceFile) {
         navigateBefore: cmd.navigateBefore,
         siteSession: cmd.siteSession,
         freshPage: cmd.freshPage,
-        defaultWindowMode: cmd.defaultWindowMode,
     };
 }
 /**

package/dist/src/build-manifest.test.js

@@ -428,6 +428,10 @@ describe('manifest helper rules', () => {
         // Unknown flags are ignored.
         expect(parseBuildManifestArgs(['--something-else']).allowRemovals).toBe(0);
     });
+    it('does not publish per-command browser window defaults', () => {
+        const manifest = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'cli-manifest.json'), 'utf8'));
+        expect(manifest.filter((entry) => Object.hasOwn(entry, 'defaultWindowMode'))).toEqual([]);
+    });
     it('keeps every browser login on the local handoff contract', () => {
         const manifest = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'cli-manifest.json'), 'utf8'));
         const logins = manifest.filter((entry) => entry.browser === true && entry.name === 'login');

package/dist/src/cli.js

@@ -526,7 +526,7 @@ async function getBrowserPage(session, targetPage, profileSelection, opts = {})
         surface: 'browser',
         ...profileRouteParams(profileSelection),
         ...(idleTimeout && idleTimeout > 0 && { idleTimeout }),
-        windowMode: opts.windowMode ?? getBrowserWindowMode(undefined, 'foreground'),
+        windowMode: opts.windowMode ?? getBrowserWindowMode(),
     });
     const targetScope = getBrowserScope(session, profileSelection?.contextId);
     const resolvedTargetPage = targetPage
@@ -540,7 +540,7 @@ async function getBrowserPage(session, targetPage, profileSelection, opts = {})
     }
     return page;
 }
-function getBrowserWindowMode(command, defaultMode) {
+function getBrowserWindowMode(command) {
     const optionRaw = getCommandOption(command, 'window');
     if (optionRaw !== undefined && optionRaw !== '') {
         if (optionRaw === 'foreground' || optionRaw === 'background')
@@ -553,7 +553,7 @@ function getBrowserWindowMode(command, defaultMode) {
             return envRaw;
         throw new Error(`WEBCMD_WINDOW must be one of: foreground, background. Received: "${envRaw}"`);
     }
-    return defaultMode;
+    return 'background';
 }
 function addBrowserTabOption(command) {
     return command.option('--tab <targetId>', BROWSER_TAB_OPTION_DESCRIPTION);
@@ -824,7 +824,7 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
         // program.parseAsync callers (tests). User-facing surface is the <session>
         // positional; main.ts argv preprocessor rewrites positional -> --session.
         .addOption(new Option('--session <name>', 'Internal — set automatically from the <session> positional').hideHelp())
-        .option('--window <mode>', 'Browser window mode: foreground or background')
+        .option('--window <mode>', 'Browser window mode: foreground or background (default: background)')
         .description('Browser control — navigate, click, type, extract, wait (no LLM needed)')
         .usage('<session> <command> [options]')
         .addHelpText('after', `
@@ -832,7 +832,7 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
 
 Examples:
   $ webcmd browser work open https://x.com
-  $ webcmd browser work open https://x.com --window background
+  $ webcmd browser work open https://x.com --window foreground
   $ webcmd browser work click 12
   $ webcmd browser work state
   $ webcmd browser work tab list
@@ -923,7 +923,7 @@ Examples:
                 const targetPage = getBrowserTargetId(command);
                 const session = getBrowserSession(command);
                 const profileSelection = getBrowserProfileSelection(command);
-                const windowMode = getBrowserWindowMode(command, 'foreground');
+                const windowMode = getBrowserWindowMode(command);
                 page = await getBrowserPage(session, targetPage, profileSelection, { windowMode });
                 await fn(page, ...args);
             }
@@ -976,7 +976,7 @@ Examples:
             const profileSelection = getBrowserProfileSelection(command);
             const contextId = profileSelection?.contextId;
             const routing = profileRouteParams(profileSelection);
-            const windowMode = getBrowserWindowMode(command, 'foreground');
+            const windowMode = getBrowserWindowMode(command);
             try {
                 const { BrowserBridge } = await import('./browser/index.js');
                 const bridge = new BrowserBridge();

package/dist/src/cli.test.js

@@ -554,6 +554,7 @@ describe('createProgram root help descriptions', () => {
                 expect.objectContaining({
                     name: 'window',
                     flags: '--window <mode>',
+                    help: 'Browser window mode: foreground or background (default: background)',
                     takes_value: 'required',
                 }),
             ]));
@@ -1164,21 +1165,22 @@ describe('browser tab targeting commands', () => {
     it('binds an existing Cloak tab by page id into a browser session', async () => {
         const program = createProgram('', '');
         await program.parseAsync(['node', 'webcmd', 'browser', '--session', 'test', 'bind', '--page', 'tab-2']);
-        expect(mockBrowserConnect).toHaveBeenCalledWith({ timeout: 45, session: 'test', surface: 'browser', windowMode: 'foreground' });
-        expect(mockBindTab).toHaveBeenCalledWith('test', { page: 'tab-2', windowMode: 'foreground' });
+        expect(mockBrowserConnect).toHaveBeenCalledWith({ timeout: 45, session: 'test', surface: 'browser', windowMode: 'background' });
+        expect(mockBindTab).toHaveBeenCalledWith('test', { page: 'tab-2', windowMode: 'background' });
         const out = lastJsonLog();
         expect(out.session).toBe('test');
         expect(out.url).toBe('https://user.example/inbox');
     });
-    it('binds an existing Cloak tab by index into a browser session', async () => {
+    it('binds an existing Cloak tab in the foreground when explicitly requested', async () => {
         const program = createProgram('', '');
-        await program.parseAsync(['node', 'webcmd', 'browser', '--session', 'test', 'bind', '--index', '1']);
+        await program.parseAsync(['node', 'webcmd', 'browser', '--session', 'test', '--window', 'foreground', 'bind', '--index', '1']);
         expect(mockBrowserConnect).toHaveBeenCalledWith({ timeout: 45, session: 'test', surface: 'browser', windowMode: 'foreground' });
         expect(mockBindTab).toHaveBeenCalledWith('test', { index: 1, windowMode: 'foreground' });
         const out = lastJsonLog();
         expect(out.session).toBe('test');
     });
-    it('passes background window mode when binding a Cloak tab', async () => {
+    it('uses the direct-browser CLI window mode before WEBCMD_WINDOW', async () => {
+        process.env.WEBCMD_WINDOW = 'foreground';
         const program = createProgram('', '');
         await program.parseAsync(['node', 'webcmd', 'browser', '--session', 'test', '--window', 'background', 'bind', '--page', 'tab-2']);
         expect(mockBrowserConnect).toHaveBeenCalledWith({ timeout: 45, session: 'test', surface: 'browser', windowMode: 'background' });
@@ -1212,15 +1214,29 @@ describe('browser tab targeting commands', () => {
     it('runs browser commands against an explicit session', async () => {
         const program = createProgram('', '');
         await program.parseAsync(['node', 'webcmd', 'browser', '--session', 'test', 'state']);
-        expect(mockBrowserConnect).toHaveBeenCalledWith({ timeout: 45, session: 'test', surface: 'browser', windowMode: 'foreground' });
+        expect(mockBrowserConnect).toHaveBeenCalledWith({ timeout: 45, session: 'test', surface: 'browser', windowMode: 'background' });
         expect(browserState.page?.snapshot).toHaveBeenCalled();
     });
-    it('passes browser --window through Commander options without relying on env pre-processing', async () => {
+    it('uses WEBCMD_WINDOW as an explicit direct-browser override', async () => {
+        process.env.WEBCMD_WINDOW = 'foreground';
         const program = createProgram('', '');
-        await program.parseAsync(['node', 'webcmd', 'browser', '--session', 'test', '--window', 'background', 'state']);
-        expect(mockBrowserConnect).toHaveBeenCalledWith({ timeout: 45, session: 'test', surface: 'browser', windowMode: 'background' });
+        await program.parseAsync(['node', 'webcmd', 'browser', '--session', 'test', 'state']);
+        expect(mockBrowserConnect).toHaveBeenCalledWith({ timeout: 45, session: 'test', surface: 'browser', windowMode: 'foreground' });
         expect(browserState.page?.snapshot).toHaveBeenCalled();
     });
+    it('rejects an invalid direct-browser --window value', async () => {
+        const program = createProgram('', '');
+        await program.parseAsync(['node', 'webcmd', 'browser', '--session', 'test', '--window', 'sideways', 'state']);
+        expect(stderrSpy.mock.calls.flat().join('')).toContain('--window must be one of: foreground, background. Received: "sideways"');
+        expect(process.exitCode).toBeDefined();
+    });
+    it('rejects an invalid direct-browser WEBCMD_WINDOW value', async () => {
+        process.env.WEBCMD_WINDOW = 'sideways';
+        const program = createProgram('', '');
+        await program.parseAsync(['node', 'webcmd', 'browser', '--session', 'test', 'state']);
+        expect(stderrSpy.mock.calls.flat().join('')).toContain('WEBCMD_WINDOW must be one of: foreground, background. Received: "sideways"');
+        expect(process.exitCode).toBeDefined();
+    });
     it('passes the opt-in AX source to browser state', async () => {
         const program = createProgram('', '');
         await program.parseAsync(['node', 'webcmd', 'browser', '--session', 'test', 'state', '--source', 'ax']);
@@ -1298,7 +1314,7 @@ describe('browser tab targeting commands', () => {
     it('unbinds a session through the daemon close-window command', async () => {
         const program = createProgram('', '');
         await program.parseAsync(['node', 'webcmd', 'browser', '--session', 'test', 'unbind']);
-        expect(mockBrowserConnect).toHaveBeenCalledWith({ timeout: 45, session: 'test', surface: 'browser', windowMode: 'foreground' });
+        expect(mockBrowserConnect).toHaveBeenCalledWith({ timeout: 45, session: 'test', surface: 'browser', windowMode: 'background' });
         expect(mockSendCommand).toHaveBeenCalledWith('close-window', { session: 'test', surface: 'browser' });
         const out = lastJsonLog();
         expect(out).toEqual({ unbound: true, session: 'test' });

package/dist/src/command-presentation.js

@@ -30,7 +30,7 @@ const BROWSER_COMMON_OPTIONS = [
     {
         flags: '--window <mode>',
         name: 'window',
-        help: 'Browser window mode: foreground or background',
+        help: 'Browser window mode: foreground or background (default: background)',
         choices: ['foreground', 'background'],
     },
     {

package/dist/src/command-presentation.test.js

@@ -54,6 +54,9 @@ describe('shared command presentation', () => {
         expect(formatSiteHelp('github', [hosted])).toBe(formatSiteHelp('github', [local]));
         expect(formatCommandHelp(hosted)).toBe(formatCommandHelp(local));
     });
+    it('states the background default in adapter browser help', () => {
+        expect(formatCommandHelp(toPresentableCommand(localCommand))).toContain('Browser window mode: foreground or background (default: background)');
+    });
     it('builds byte-identical structured and display list rows', () => {
         const local = toPresentableCommand(localCommand);
         const hosted = toPresentableCommand(hostedCommand);

package/dist/src/command-surface.js

@@ -46,7 +46,7 @@ export function configureCommandSurface(command, metadata) {
         .option('-v, --verbose', 'Debug output', false);
     if (metadata.browser) {
         command
-            .option('--window <mode>', `Browser window mode: ${BROWSER_WINDOW_MODES.join(' or ')}`)
+            .option('--window <mode>', `Browser window mode: ${BROWSER_WINDOW_MODES.join(' or ')} (default: background)`)
             .option('--site-session <mode>', `Adapter site session lifecycle: ${SITE_SESSION_MODES.join(' or ')}`)
             .option('--keep-tab <bool>', 'Keep the browser tab lease after the command finishes');
     }

package/dist/src/command-surface.test.js

@@ -143,6 +143,10 @@ describe('configureCommandSurface', () => {
         const longFlags = command.options.map((option) => option.long);
         for (const flag of expected)
             expect(longFlags).toContain(flag);
+        if (browser) {
+            expect(command.options.find((option) => option.long === '--window')?.description)
+                .toBe('Browser window mode: foreground or background (default: background)');
+        }
         if (!browser) {
             expect(longFlags).not.toContain('--window');
             expect(longFlags).not.toContain('--site-session');

package/dist/src/commands/auth.js

@@ -96,7 +96,6 @@ function quickCheckCommand(cmd, timeoutSeconds) {
         func: cmd.authStatus.quickCheck,
         navigateBefore: false,
         siteSession: 'ephemeral',
-        defaultWindowMode: 'background',
     }, timeoutSeconds);
 }
 function normalizeQuickResult(result) {
@@ -179,7 +178,6 @@ function refreshCommand(cmd, timeoutSeconds) {
         func: refreshFunc,
         navigateBefore: false,
         siteSession: 'persistent',
-        defaultWindowMode: 'background',
     }, timeoutSeconds);
 }
 function normalizeRefreshStatus(result) {

package/dist/src/commands/auth.test.js

@@ -54,7 +54,6 @@ describe('auth status collection', () => {
             name: 'whoami',
             navigateBefore: false,
             siteSession: 'ephemeral',
-            defaultWindowMode: 'background',
         });
     });
     it('marks sites without quickCheck as unknown unless --full is used', async () => {
@@ -116,7 +115,6 @@ describe('auth refresh collection', () => {
             name: 'whoami',
             navigateBefore: false,
             siteSession: 'persistent',
-            defaultWindowMode: 'background',
         });
         expect(executeCommandMock.mock.calls[0]?.[3]).toMatchObject({
             siteSession: 'persistent',

package/dist/src/discovery.js

@@ -212,7 +212,6 @@ async function loadFromManifest(manifestPath, clisDir) {
                 navigateBefore: entry.navigateBefore,
                 siteSession: entry.siteSession,
                 freshPage: entry.freshPage,
-                defaultWindowMode: entry.defaultWindowMode,
                 _lazy: true,
                 _modulePath: modulePath,
             };

package/dist/src/execution.js

@@ -183,7 +183,7 @@ export async function executeCommand(cmd, rawKwargs, debug = false, opts = {}) {
             const siteSession = resolveSiteSession(cmd, opts.siteSession);
             const session = resolveAdapterBrowserSession(cmd, siteSession);
             const keepTab = resolveKeepTab(siteSession, opts.keepTab);
-            const windowMode = resolveBrowserWindowMode(cmd.defaultWindowMode ?? 'background', opts.windowMode);
+            const windowMode = resolveBrowserWindowMode(opts.windowMode);
             const surface = 'adapter';
             const canonicalCommand = fullName(cmd);
             const leaseEligible = surface === 'adapter'
@@ -490,10 +490,10 @@ function normalizeWindowMode(name, raw) {
         return raw;
     throw new ArgumentError(`${name} must be one of: foreground, background. Received: "${String(raw)}"`);
 }
-function resolveBrowserWindowMode(defaultMode = 'background', rawOption) {
+function resolveBrowserWindowMode(rawOption) {
     return normalizeWindowMode('--window', rawOption)
         ?? normalizeWindowMode('WEBCMD_WINDOW', process.env.WEBCMD_WINDOW)
-        ?? defaultMode;
+        ?? 'background';
 }
 /**
  * Resolve the user-controllable `--timeout` arg, in seconds.

package/dist/src/execution.test.js

@@ -848,7 +848,8 @@ describe('executeCommand — non-browser timeout', () => {
             vi.restoreAllMocks();
         }
     });
-    it('lets browser common options override adapter window and keep-tab defaults', async () => {
+    it('uses explicit adapter options before WEBCMD_WINDOW', async () => {
+        vi.stubEnv('WEBCMD_WINDOW', 'background');
         const closeWindow = vi.fn().mockResolvedValue(undefined);
         const mockPage = { closeWindow };
         const sessionOpts = [];
@@ -865,15 +866,21 @@ describe('executeCommand — non-browser timeout', () => {
             strategy: Strategy.PUBLIC,
             func: async () => [{ ok: true }],
         });
-        await executeCommand(cmd, {}, false, {
-            windowMode: 'foreground',
-            keepTab: 'true',
-        });
-        expect(sessionOpts[0]).toMatchObject({ windowMode: 'foreground' });
-        expect(closeWindow).not.toHaveBeenCalled();
-        vi.restoreAllMocks();
+        try {
+            await executeCommand(cmd, {}, false, {
+                windowMode: 'foreground',
+                keepTab: 'true',
+            });
+            expect(sessionOpts[0]).toMatchObject({ windowMode: 'foreground' });
+            expect(closeWindow).not.toHaveBeenCalled();
+        }
+        finally {
+            vi.unstubAllEnvs();
+            vi.restoreAllMocks();
+        }
     });
-    it('uses command defaultWindowMode when the user does not pass --window', async () => {
+    it('uses WEBCMD_WINDOW as an explicit adapter override', async () => {
+        vi.stubEnv('WEBCMD_WINDOW', 'foreground');
         const closeWindow = vi.fn().mockResolvedValue(undefined);
         const mockPage = { closeWindow };
         const sessionOpts = [];
@@ -884,16 +891,62 @@ describe('executeCommand — non-browser timeout', () => {
         });
         const cmd = cli({
             site: 'test-execution',
-            name: 'browser-default-window-mode', access: 'write',
-            description: 'test command default window mode',
+            name: 'browser-env-window-mode', access: 'read',
+            description: 'test browser environment window mode',
             browser: true,
             strategy: Strategy.PUBLIC,
-            defaultWindowMode: 'foreground',
             func: async () => [{ ok: true }],
         });
-        await executeCommand(cmd, {});
-        expect(sessionOpts[0]).toMatchObject({ windowMode: 'foreground' });
-        vi.restoreAllMocks();
+        try {
+            await executeCommand(cmd, {});
+            expect(sessionOpts[0]).toMatchObject({ windowMode: 'foreground' });
+        }
+        finally {
+            vi.unstubAllEnvs();
+            vi.restoreAllMocks();
+        }
+    });
+    it('rejects an invalid adapter --window value', async () => {
+        const mockPage = { closeWindow: vi.fn().mockResolvedValue(undefined) };
+        vi.spyOn(capRouting, 'shouldUseBrowserSession').mockReturnValue(true);
+        vi.spyOn(runtime, 'browserSession').mockImplementation(async (_Factory, fn) => fn(mockPage));
+        const cmd = cli({
+            site: 'test-execution',
+            name: 'browser-invalid-window-mode', access: 'read',
+            description: 'test invalid browser window mode',
+            browser: true,
+            strategy: Strategy.PUBLIC,
+            func: async () => [{ ok: true }],
+        });
+        try {
+            await expect(executeCommand(cmd, {}, false, {
+                windowMode: 'sideways',
+            })).rejects.toThrow('--window must be one of: foreground, background. Received: "sideways"');
+        }
+        finally {
+            vi.restoreAllMocks();
+        }
+    });
+    it('rejects an invalid adapter WEBCMD_WINDOW value', async () => {
+        vi.stubEnv('WEBCMD_WINDOW', 'sideways');
+        const mockPage = { closeWindow: vi.fn().mockResolvedValue(undefined) };
+        vi.spyOn(capRouting, 'shouldUseBrowserSession').mockReturnValue(true);
+        vi.spyOn(runtime, 'browserSession').mockImplementation(async (_Factory, fn) => fn(mockPage));
+        const cmd = cli({
+            site: 'test-execution',
+            name: 'browser-invalid-env-window-mode', access: 'read',
+            description: 'test invalid browser environment window mode',
+            browser: true,
+            strategy: Strategy.PUBLIC,
+            func: async () => [{ ok: true }],
+        });
+        try {
+            await expect(executeCommand(cmd, {})).rejects.toThrow('WEBCMD_WINDOW must be one of: foreground, background. Received: "sideways"');
+        }
+        finally {
+            vi.unstubAllEnvs();
+            vi.restoreAllMocks();
+        }
     });
     it('does not re-run custom validation when args are already prepared', async () => {
         const validateArgs = vi.fn();

package/dist/src/hosted/browser-args.js

@@ -21,7 +21,7 @@ export function parseHostedBrowserStructure(argv) {
     const browser = root
         .command('browser')
         .addOption(new Option('--session <name>', 'Internal — set automatically from the <session> positional').hideHelp())
-        .option('--window <mode>', 'Browser window mode: foreground or background')
+        .option('--window <mode>', 'Browser window mode: foreground or background (default: background)')
         .description('Browser control — navigate, click, type, extract, wait (no LLM needed)')
         .usage('<session> <command> [options]')
         .addHelpText('after', `
@@ -29,7 +29,7 @@ export function parseHostedBrowserStructure(argv) {
 
 Examples:
   $ webcmd browser work open https://x.com
-  $ webcmd browser work open https://x.com --window background
+  $ webcmd browser work open https://x.com --window foreground
   $ webcmd browser work click 12
   $ webcmd browser work state
   $ webcmd browser work tab list

package/dist/src/hosted/browser-args.test.js

@@ -67,6 +67,16 @@ function parseHosted(argv) {
     return parseHostedBrowserStructure(rewriteBrowserArgv(argv));
 }
 describe('hosted browser canonical Commander values', () => {
+    it('states the background default in hosted browser help', () => {
+        try {
+            parseHostedBrowserStructure(['browser', '--help']);
+            throw new Error('Expected hosted browser help');
+        }
+        catch (error) {
+            expect(error).toBeInstanceOf(HostedBrowserHelp);
+            expect(error.output).toContain('Browser window mode: foreground or background (default: background)');
+        }
+    });
     it('matches the actual local action boundary for every catalogued browser leaf', () => {
         for (const contract of browserCommandCatalog) {
             const argv = ['browser', 'work', ...contract.command.split('/'), ...allPositionals(contract.command)];

package/dist/src/hosted/client.d.ts

@@ -1,10 +1,15 @@
 import { CliError, type ExitCode } from '../errors.js';
-import type { HostedBrowserActionRequest, HostedBrowserActionResponse, HostedBrowserFinishRequest, HostedBrowserFinishResponse, HostedBrowserRunActionInput, HostedBrowserRunActionResponse, HostedBrowserRunRequest, HostedBrowserRunResponse, HostedExecution, HostedExecuteResponse, HostedPrepareExecutionResponse, HostedProfileResponse, HostedProfilesResponse, HostedUploadArtifactResponse, HostedManifest, HostedTraceReceipt } from './types.js';
+import type { HostedBrowserActionRequest, HostedBrowserActionResponse, HostedBrowserFinishRequest, HostedBrowserFinishResponse, HostedBrowserRunActionInput, HostedBrowserRunActionResponse, HostedBrowserRunRequest, HostedBrowserRunResponse, HostedExecution, HostedExecuteResponse, HostedPrepareExecutionResponse, HostedProfilesResponse, HostedUploadArtifactResponse, HostedManifest, HostedTraceReceipt } from './types.js';
 export interface HostedClientOptions {
     apiBaseUrl: string;
     apiKey: string;
+    workspace?: string;
     fetchImpl?: typeof fetch;
 }
+/**
+ * Resolves the active workspace from CLI flags/env, precedence: --workspace flag > WEBCMD_WORKSPACE env > undefined.
+ */
+export declare function resolveWorkspace(argv: readonly string[], env: NodeJS.ProcessEnv): string | undefined;
 export declare class HostedClientError extends CliError {
     readonly execution?: HostedExecution;
     readonly trace?: HostedTraceReceipt;
@@ -16,19 +21,12 @@ export declare class HostedClientError extends CliError {
 export declare class HostedClient {
     private readonly apiBaseUrl;
     private readonly apiKey;
+    private readonly workspace;
     private readonly fetchImpl;
     constructor(options: HostedClientOptions);
     getMe(): Promise<unknown>;
     getManifest(): Promise<HostedManifest>;
-    listProfiles(filters?: {
-        name?: string;
-        userId?: string;
-    }): Promise<HostedProfilesResponse>;
-    createProfile(input: {
-        name: string;
-        userId?: string;
-    }): Promise<HostedProfileResponse>;
-    getProfile(profileId: string): Promise<HostedProfileResponse>;
+    listProfiles(): Promise<HostedProfilesResponse>;
     deleteProfile(profileId: string): Promise<{
         ok: true;
         deleted: true;

package/dist/src/hosted/client.js

@@ -1,4 +1,20 @@
 import { attachTraceReceipt, CliError, EXIT_CODES } from '../errors.js';
+/**
+ * Resolves the active workspace from CLI flags/env, precedence: --workspace flag > WEBCMD_WORKSPACE env > undefined.
+ */
+export function resolveWorkspace(argv, env) {
+    const idx = argv.indexOf('--workspace');
+    if (idx >= 0 && argv[idx + 1])
+        return argv[idx + 1];
+    const equalsForm = argv.find(arg => arg.startsWith('--workspace='));
+    if (equalsForm !== undefined) {
+        const value = equalsForm.slice('--workspace='.length).trim();
+        if (value)
+            return value;
+    }
+    const fromEnv = env.WEBCMD_WORKSPACE?.trim();
+    return fromEnv ? fromEnv : undefined;
+}
 export class HostedClientError extends CliError {
     execution;
     trace;
@@ -13,10 +29,12 @@ export class HostedClientError extends CliError {
 export class HostedClient {
     apiBaseUrl;
     apiKey;
+    workspace;
     fetchImpl;
     constructor(options) {
         this.apiBaseUrl = options.apiBaseUrl.replace(/\/+$/, '');
         this.apiKey = options.apiKey;
+        this.workspace = options.workspace;
         this.fetchImpl = options.fetchImpl ?? fetch;
     }
     async getMe() {
@@ -29,36 +47,13 @@ export class HostedClient {
         }
         return body.manifest;
     }
-    async listProfiles(filters = {}) {
-        const params = new URLSearchParams();
-        if (filters.name !== undefined)
-            params.set('name', filters.name);
-        if (filters.userId !== undefined)
-            params.set('userId', filters.userId);
-        const query = params.toString();
-        const body = await this.request(`/v1/profiles${query ? `?${query}` : ''}`);
+    async listProfiles() {
+        const body = await this.request('/v1/profiles');
         if (!isHostedProfilesResponse(body)) {
             throw protocolError('Webcmd Cloud returned an invalid profiles response.');
         }
         return body;
     }
-    async createProfile(input) {
-        const body = await this.request('/v1/profiles', {
-            method: 'POST',
-            body: JSON.stringify(input),
-        });
-        if (!isHostedProfileResponse(body)) {
-            throw protocolError('Webcmd Cloud returned an invalid profile response.');
-        }
-        return body;
-    }
-    async getProfile(profileId) {
-        const body = await this.request(`/v1/profiles/${encodeURIComponent(profileId)}`);
-        if (!isHostedProfileResponse(body)) {
-            throw protocolError('Webcmd Cloud returned an invalid profile response.');
-        }
-        return body;
-    }
     async deleteProfile(profileId) {
         const body = await this.request(`/v1/profiles/${encodeURIComponent(profileId)}`, { method: 'DELETE' });
         if (!hasExactKeys(body, ['ok', 'deleted']) || body.ok !== true || body.deleted !== true) {
@@ -124,6 +119,7 @@ export class HostedClient {
             headers: {
                 accept: 'application/octet-stream',
                 authorization: `Bearer ${this.apiKey}`,
+                ...(this.workspace ? { 'x-webcmd-workspace': this.workspace } : {}),
             },
         });
         if (!response.ok) {
@@ -189,6 +185,7 @@ export class HostedClient {
                 accept: 'application/json',
                 ...(init.body ? { 'content-type': 'application/json' } : {}),
                 authorization: `Bearer ${this.apiKey}`,
+                ...(this.workspace ? { 'x-webcmd-workspace': this.workspace } : {}),
                 ...(init.headers ?? {}),
             },
         });
@@ -311,19 +308,14 @@ function isHostedProfilesResponse(value) {
         && Array.isArray(value.profiles)
         && value.profiles.every(isHostedPublicProfile);
 }
-function isHostedProfileResponse(value) {
-    return hasExactKeys(value, ['ok', 'profile'])
-        && value.ok === true
-        && isHostedPublicProfile(value.profile);
-}
 function isHostedPublicProfile(value) {
     return hasExactKeys(value, [
-        'id', 'name', 'userId', 'default', 'status',
+        'id', 'name', 'workspace', 'default', 'status',
         'createdAt', 'updatedAt', 'lastUsedAt',
     ])
         && typeof value.id === 'string'
         && (value.name === null || typeof value.name === 'string')
-        && (value.userId === null || typeof value.userId === 'string')
+        && (value.workspace === null || typeof value.workspace === 'string')
         && typeof value.default === 'boolean'
         && (value.status === 'pending' || value.status === 'available')
         && typeof value.createdAt === 'string'
@@ -334,7 +326,7 @@ function isHostedManifestCommand(value) {
     if (!hasOnlyKeys(value, [
         'site', 'name', 'aliases', 'command', 'description', 'access', 'example', 'domain', 'strategy', 'browser',
         'args', 'columns', 'pipeline', 'defaultFormat', 'type', 'modulePath', 'sourceFile', 'navigateBefore',
-        'siteSession', 'freshPage', 'defaultWindowMode', 'adapterPackageId', 'adapterPackageName', 'adapterPackageVersion',
+        'siteSession', 'freshPage', 'adapterPackageId', 'adapterPackageName', 'adapterPackageVersion',
     ]))
         return false;
     if (typeof value.site !== 'string' || typeof value.name !== 'string' || typeof value.command !== 'string')
@@ -355,7 +347,7 @@ function isHostedManifestCommand(value) {
         return false;
     if (value.pipeline !== undefined && (!Array.isArray(value.pipeline) || !value.pipeline.every(isRecord)))
         return false;
-    for (const key of ['type', 'modulePath', 'sourceFile', 'siteSession', 'defaultWindowMode', 'adapterPackageId', 'adapterPackageName', 'adapterPackageVersion']) {
+    for (const key of ['type', 'modulePath', 'sourceFile', 'siteSession', 'adapterPackageId', 'adapterPackageName', 'adapterPackageVersion']) {
         if (value[key] !== undefined && typeof value[key] !== 'string')
             return false;
     }