@agentrhq/webcmd 0.4.0 → 0.4.2

package/clis/amazon-in/wishlist.js

@@ -0,0 +1,98 @@
+import {
+  CommandExecutionError,
+  EmptyResultError,
+  TimeoutError,
+} from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { normalizeWishlistRows } from './parsers.js';
+import { gotoAmazon, SITE, WISHLIST_URL } from './shared.js';
+
+cli({
+  site: SITE,
+  name: 'wishlist',
+  access: 'read',
+  description: 'Fetch current prices for products in the default Amazon.in wishlist',
+  domain: 'amazon.in',
+  strategy: Strategy.UI,
+  browser: true,
+  navigateBefore: false,
+  siteSession: 'persistent',
+  args: [
+    {
+      name: 'filter',
+      default: 'unpurchased',
+      choices: ['unpurchased', 'all'],
+      help: 'Wishlist items to include',
+    },
+  ],
+  columns: [
+    'list_name', 'item_id', 'asin', 'title', 'price', 'mrp',
+    'availability', 'size', 'colour', 'image_url', 'product_url',
+  ],
+  func: async (page, args) => {
+    const url = new URL(WISHLIST_URL);
+    url.searchParams.set('type', 'wishlist');
+    url.searchParams.set('filter', args.filter ?? 'unpurchased');
+    url.searchParams.set('sort', 'date-added');
+    url.searchParams.set('viewType', 'list');
+    await gotoAmazon(page, url.href, 'wishlist');
+
+    let reachedEnd = false;
+    for (let step = 0; step < 100; step += 1) {
+      reachedEnd = await page.evaluate(`
+        (() => Boolean(document.querySelector('#endOfListMarker')))()
+      `);
+      if (reachedEnd) break;
+      await page.scroll('down', 700);
+      await page.sleep(0.25);
+    }
+    if (!reachedEnd) {
+      throw new TimeoutError(
+        'Amazon.in wishlist loading',
+        25,
+        'Open the wishlist in the Webcmd browser and check whether Amazon is still loading items.',
+      );
+    }
+
+    const payload = await page.evaluate(`
+      (() => {
+        const text = (node) => (node?.textContent || '').replace(/\\s+/g, ' ').trim();
+        const cards = [...document.querySelectorAll('#g-items li.g-item-sortable')].map((card) => {
+          const productLinks = [...card.querySelectorAll('a[href*="/dp/"]')];
+          const productLink = productLinks.find((link) => link.title) || productLinks[0];
+          const variants = [...card.querySelectorAll('#twisterText')].map((node) => text(node));
+          return {
+            cardItemId: card.getAttribute('data-itemid') || '',
+            cardHref: productLink?.href || '',
+            cardTitle: productLink?.title || text(productLink),
+            cardPriceText: text(card.querySelector('.price-section .a-price .a-offscreen, .a-price .a-offscreen')),
+            cardMrpText: text(card.querySelector('.wl-deal-price.a-text-strike, .a-price.a-text-price .a-offscreen')),
+            cardAvailabilityText: text(card.querySelector('[id^="availability-"], .itemAvailability, .a-color-price')),
+            cardSizeText: variants.find((value) => /^size\\s*:/i.test(value))?.replace(/^size\\s*:\\s*/i, '') || '',
+            cardColourText: variants.find((value) => /^colou?r\\s*:/i.test(value))?.replace(/^colou?r\\s*:\\s*/i, '') || '',
+            cardImageUrl: card.querySelector('img[alt]')?.currentSrc || card.querySelector('img[alt]')?.src || '',
+          };
+        });
+        return {
+          listName: text(document.querySelector('#profile-list-name')),
+          cards,
+          empty: /no items|this list is empty/i.test(document.body?.innerText || ''),
+        };
+      })()
+    `);
+    if (!payload?.listName) {
+      throw new CommandExecutionError('Amazon.in wishlist name could not be read');
+    }
+    if (!payload.cards?.length) {
+      if (payload.empty) throw new EmptyResultError('amazon-in wishlist');
+      throw new CommandExecutionError('Amazon.in wishlist exposed no item cards');
+    }
+    try {
+      return normalizeWishlistRows(payload.listName, payload.cards);
+    } catch (error) {
+      throw new CommandExecutionError(
+        `Amazon.in wishlist details could not be normalized: ${error.message}`,
+      );
+    }
+  },
+});

package/dist/src/completion-shared.js

@@ -38,6 +38,7 @@ export const HOSTED_ROOT_HELP = {
         { name: 'browser', description: 'Browser control through a hosted browser session' },
         { name: 'completion <shell>', description: 'Output a shell completion script' },
         { name: 'list', description: 'List all available hosted CLI commands' },
+        { name: 'profile', description: 'Manage hosted browser profiles' },
         { name: 'setup', description: 'Configure local or hosted mode' },
     ],
     localOnlyCommands: [
@@ -49,7 +50,6 @@ export const HOSTED_ROOT_HELP = {
         { name: 'doctor', description: 'Diagnose local browser bridge connectivity' },
         { name: 'external', description: 'Manage local CLI passthrough commands' },
         { name: 'plugin', description: 'Manage plugins installed on this computer' },
-        { name: 'profile', description: 'Manage profiles in the local browser runtime' },
         { name: 'skills', description: 'Manage bundled skills on this computer' },
         { name: 'validate', description: 'Validate local CLI definitions' },
         { name: 'verify', description: 'Validate and smoke-test local adapters' },

package/dist/src/docs-sync-review.js

@@ -105,6 +105,12 @@ const BROWSER_DOCUMENTATION = [
     'skills/webcmd-browser/SKILL.md',
     'skills/webcmd-usage/SKILL.md',
 ];
+const HOSTED_DOCUMENTATION = [
+    ...BROWSER_DOCUMENTATION,
+    'docs/authentication-and-profiles.mdx',
+    'docs/local-or-cloud.mdx',
+];
+const HOSTED_PROFILE_PATHS = /^(?:src\/completion-shared|src\/hosted\/(?:browser-args|client|runner|types))\.ts$/;
 const ADAPTER_DOCUMENTATION = [
     'README.md',
     'docs/authoring.mdx',
@@ -116,11 +122,13 @@ const ADAPTER_DOCUMENTATION = [
 export function selectDocumentationPaths(files) {
     const selected = new Set();
     for (const file of files) {
-        const paths = /^(?:src\/browser\/|src\/hosted\/)/.test(file.path)
-            ? BROWSER_DOCUMENTATION
-            : /^(?:clis\/|plugins\/|src\/plugin)/.test(file.path)
-                ? ADAPTER_DOCUMENTATION
-                : GENERAL_DOCUMENTATION;
+        const paths = HOSTED_PROFILE_PATHS.test(file.path)
+            ? HOSTED_DOCUMENTATION
+            : /^src\/browser\//.test(file.path)
+                ? BROWSER_DOCUMENTATION
+                : /^(?:clis\/|plugins\/|src\/plugin)/.test(file.path)
+                    ? ADAPTER_DOCUMENTATION
+                    : GENERAL_DOCUMENTATION;
         paths.forEach((path) => selected.add(path));
     }
     return [...selected].sort();

package/dist/src/docs-sync-review.test.js

@@ -95,6 +95,42 @@ describe('review context', () => {
             'skills/webcmd-usage/SKILL.md',
         ]);
     });
+    it('selects profile documentation for hosted profile changes', () => {
+        expect(selectDocumentationPaths([changed('src/hosted/runner.ts')])).toEqual([
+            'README.md',
+            'docs/agent-prompts.mdx',
+            'docs/authentication-and-profiles.mdx',
+            'docs/browser-and-sitemap-memory.mdx',
+            'docs/cli-reference.mdx',
+            'docs/concepts.mdx',
+            'docs/local-or-cloud.mdx',
+            'skills/webcmd-browser-sitemap/SKILL.md',
+            'skills/webcmd-browser/SKILL.md',
+            'skills/webcmd-usage/SKILL.md',
+        ]);
+    });
+    it('selects profile documentation for hosted root command changes', () => {
+        expect(selectDocumentationPaths([changed('src/completion-shared.ts')])).toEqual([
+            'README.md',
+            'docs/agent-prompts.mdx',
+            'docs/authentication-and-profiles.mdx',
+            'docs/browser-and-sitemap-memory.mdx',
+            'docs/cli-reference.mdx',
+            'docs/concepts.mdx',
+            'docs/local-or-cloud.mdx',
+            'skills/webcmd-browser-sitemap/SKILL.md',
+            'skills/webcmd-browser/SKILL.md',
+            'skills/webcmd-usage/SKILL.md',
+        ]);
+    });
+    it('does not select profile documentation for unrelated hosted changes', () => {
+        expect(selectDocumentationPaths([changed('src/hosted/files.ts')])).toEqual([
+            'README.md',
+            'docs/cli-reference.mdx',
+            'docs/concepts.mdx',
+            'skills/webcmd-usage/SKILL.md',
+        ]);
+    });
     it('selects adapter and plugin documentation', () => {
         expect(selectDocumentationPaths([changed('clis/reddit/search.js')])).toEqual([
             'README.md',

package/dist/src/generate-release-notes-cli.test.js

@@ -218,7 +218,7 @@ describe('runGenerateReleaseNotes', () => {
         expect(workflow).toContain('release_body_file="$RUNNER_TEMP/release-body.md"');
         expect(workflow).toContain('release_edit_args+=(--title "$release_title")');
         expect(workflow).toContain('release_edit_args+=(--notes-file "$release_body_file")');
-        expect(workflow).toContain('if gh release edit "${{ steps.release.outputs.tag_name }}" "${release_edit_args[@]}"; then');
+        expect(workflow).toContain('if gh release edit "${{ steps.release.outputs.tag_name || inputs.publish_tag }}" "${release_edit_args[@]}"; then');
         expect(workflow).toMatch(/Enhanced release notes could not be applied; keeping release-please notes\./);
     });
 });

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

@@ -3,8 +3,13 @@ import type { HostedBrowserActionRequest, HostedBrowserActionResponse, HostedBro
 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,11 +21,16 @@ 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(): Promise<HostedProfilesResponse>;
+    deleteProfile(profileId: string): Promise<{
+        ok: true;
+        deleted: true;
+    }>;
     execute(input: {
         command: string;
         args: Record<string, unknown>;

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() {
@@ -36,6 +54,13 @@ export class HostedClient {
         }
         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) {
+            throw protocolError('Webcmd Cloud returned an invalid profile deletion response.');
+        }
+        return { ok: true, deleted: true };
+    }
     async execute(input) {
         const traceMode = normalizeTraceMode(input.trace);
         const body = await this.request('/v1/execute', {
@@ -94,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) {
@@ -159,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 ?? {}),
             },
         });
@@ -282,11 +309,17 @@ function isHostedProfilesResponse(value) {
         && value.profiles.every(isHostedPublicProfile);
 }
 function isHostedPublicProfile(value) {
-    return hasExactKeys(value, ['name', 'default', 'status', 'createdAt', 'lastUsedAt'])
-        && typeof value.name === 'string'
+    return hasExactKeys(value, [
+        'id', 'name', 'workspace', 'default', 'status',
+        'createdAt', 'updatedAt', 'lastUsedAt',
+    ])
+        && typeof value.id === 'string'
+        && (value.name === null || typeof value.name === 'string')
+        && (value.workspace === null || typeof value.workspace === 'string')
         && typeof value.default === 'boolean'
-        && value.status === 'available'
+        && (value.status === 'pending' || value.status === 'available')
         && typeof value.createdAt === 'string'
+        && typeof value.updatedAt === 'string'
         && typeof value.lastUsedAt === 'string';
 }
 function isHostedManifestCommand(value) {

package/dist/src/hosted/client.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { HostedClient } from './client.js';
+import { HostedClient, resolveWorkspace } from './client.js';
 const invalidTraceUrlCases = [
     {
         name: 'raw absolute Kernel URL with token',
@@ -165,31 +165,66 @@ describe('HostedClient', () => {
         });
         await expect(client.getManifest()).rejects.toMatchObject({ code: 'HOSTED_PROTOCOL' });
     });
-    it('parses hosted profile rows without provider identifiers', async () => {
+    it('manages public hosted profiles over the authenticated HTTP API', async () => {
+        const requests = [];
+        const profile = {
+            id: 'profile_work',
+            name: 'Work',
+            workspace: 'user_64256',
+            default: false,
+            status: 'available',
+            createdAt: '2026-07-08T00:00:00.000Z',
+            updatedAt: '2026-07-08T00:00:00.000Z',
+            lastUsedAt: '2026-07-08T00:00:00.000Z',
+        };
         const client = new HostedClient({
             apiBaseUrl: 'https://api.example.com',
             apiKey: 'wcmd_live_test',
-            fetchImpl: async () => new Response(JSON.stringify({
-                ok: true,
-                profiles: [{
-                        name: 'default',
-                        default: true,
-                        status: 'available',
-                        createdAt: '2026-07-08T00:00:00.000Z',
-                        lastUsedAt: '2026-07-08T00:00:00.000Z',
-                    }],
-            }), { status: 200 }),
+            fetchImpl: async (url, init) => {
+                requests.push({
+                    url: String(url),
+                    method: init?.method ?? 'GET',
+                    ...(init?.body ? { body: String(init.body) } : {}),
+                });
+                const path = new URL(String(url)).pathname;
+                if (path.startsWith('/v1/profiles/') && init?.method === 'DELETE') {
+                    return new Response(JSON.stringify({ ok: true, deleted: true }));
+                }
+                return new Response(JSON.stringify({ ok: true, profiles: [profile] }));
+            },
         });
-        await expect(client.listProfiles()).resolves.toEqual({
-            ok: true,
-            profiles: [{
-                    name: 'default',
-                    default: true,
-                    status: 'available',
-                    createdAt: '2026-07-08T00:00:00.000Z',
-                    lastUsedAt: '2026-07-08T00:00:00.000Z',
-                }],
+        await expect(client.listProfiles()).resolves.toEqual({ ok: true, profiles: [profile] });
+        await expect(client.deleteProfile('profile/work')).resolves.toEqual({ ok: true, deleted: true });
+        expect(requests).toEqual([
+            { url: 'https://api.example.com/v1/profiles', method: 'GET' },
+            { url: 'https://api.example.com/v1/profiles/profile%2Fwork', method: 'DELETE' },
+        ]);
+    });
+    it.each([
+        { name: 'private provider field', change: { kernelProfileId: 'private' } },
+        { name: 'missing updatedAt', change: { updatedAt: undefined } },
+        { name: 'non-nullable name shape', change: { name: 7 } },
+        { name: 'non-nullable workspace shape', change: { workspace: false } },
+    ])('rejects a hosted profile with $name', async ({ change }) => {
+        const profile = {
+            id: 'profile_work',
+            name: null,
+            workspace: null,
+            default: false,
+            status: 'pending',
+            createdAt: '2026-07-08T00:00:00.000Z',
+            updatedAt: '2026-07-08T00:00:00.000Z',
+            lastUsedAt: '2026-07-08T00:00:00.000Z',
+            ...change,
+        };
+        if (change.updatedAt === undefined)
+            delete profile.updatedAt;
+        const client = new HostedClient({
+            apiBaseUrl: 'https://api.example.com',
+            apiKey: 'key',
+            fetchImpl: async () => new Response(JSON.stringify({ ok: true, profiles: [profile] })),
         });
+        await expect(client.listProfiles()).rejects.toMatchObject({ code: 'HOSTED_PROTOCOL' });
     });
     it('maps hosted error envelopes to CliError-compatible errors', async () => {
         const client = new HostedClient({
@@ -797,4 +832,77 @@ describe('HostedClient', () => {
             },
         ]);
     });
+    it('attaches the workspace header when a workspace is configured', async () => {
+        const requests = [];
+        const client = new HostedClient({
+            apiBaseUrl: 'https://api.example.com',
+            apiKey: 'key',
+            workspace: resolveWorkspace([], { WEBCMD_WORKSPACE: 'user_64256' }),
+            fetchImpl: async (_url, init) => {
+                requests.push({ workspace: new Headers(init?.headers).get('x-webcmd-workspace') });
+                return new Response(JSON.stringify({
+                    ok: true,
+                    result: [],
+                    execution: { id: 'exec_1', command: 'github/whoami', status: 'succeeded' },
+                }), { status: 200 });
+            },
+        });
+        await client.execute({ command: 'github/whoami', args: {} });
+        expect(requests).toEqual([{ workspace: 'user_64256' }]);
+    });
+    it('attaches the workspace header for the --workspace=<value> equals form', async () => {
+        const requests = [];
+        const client = new HostedClient({
+            apiBaseUrl: 'https://api.example.com',
+            apiKey: 'key',
+            workspace: resolveWorkspace(['--workspace=user_64256'], {}),
+            fetchImpl: async (_url, init) => {
+                requests.push({ workspace: new Headers(init?.headers).get('x-webcmd-workspace') });
+                return new Response(JSON.stringify({
+                    ok: true,
+                    result: [],
+                    execution: { id: 'exec_1', command: 'github/whoami', status: 'succeeded' },
+                }), { status: 200 });
+            },
+        });
+        await client.execute({ command: 'github/whoami', args: {} });
+        expect(requests).toEqual([{ workspace: 'user_64256' }]);
+    });
+    it('omits the workspace header when no workspace is configured', async () => {
+        const requests = [];
+        const client = new HostedClient({
+            apiBaseUrl: 'https://api.example.com',
+            apiKey: 'key',
+            fetchImpl: async (_url, init) => {
+                requests.push({ workspace: new Headers(init?.headers).get('x-webcmd-workspace') });
+                return new Response(JSON.stringify({
+                    ok: true,
+                    result: [],
+                    execution: { id: 'exec_1', command: 'github/whoami', status: 'succeeded' },
+                }), { status: 200 });
+            },
+        });
+        await client.execute({ command: 'github/whoami', args: {} });
+        expect(requests).toEqual([{ workspace: null }]);
+    });
+});
+describe('resolveWorkspace', () => {
+    it('returns the --workspace flag value when present', () => {
+        expect(resolveWorkspace(['--workspace', 'flagws'], {})).toBe('flagws');
+    });
+    it('returns the --workspace=<value> flag value when present', () => {
+        expect(resolveWorkspace(['--workspace=user_64256'], {})).toBe('user_64256');
+    });
+    it('--workspace overrides the env var', () => {
+        expect(resolveWorkspace(['--workspace', 'flagws'], { WEBCMD_WORKSPACE: 'envws' })).toBe('flagws');
+    });
+    it('falls back to WEBCMD_WORKSPACE when no flag is present', () => {
+        expect(resolveWorkspace([], { WEBCMD_WORKSPACE: 'envws' })).toBe('envws');
+    });
+    it('trims WEBCMD_WORKSPACE', () => {
+        expect(resolveWorkspace([], { WEBCMD_WORKSPACE: '  envws  ' })).toBe('envws');
+    });
+    it('returns undefined when neither --workspace nor WEBCMD_WORKSPACE is set', () => {
+        expect(resolveWorkspace([], {})).toBeUndefined();
+    });
 });

package/dist/src/hosted/manifest.test.js

@@ -98,6 +98,7 @@ describe('hosted manifest helpers', () => {
         expect(result).toEqual({ handled: true, exitCode: 0 });
         expect(stdout.text()).toBe(formatRootHelp(HOSTED_ROOT_HELP));
         expect(stdout.text()).toContain('completion');
+        expect(stdout.text()).toMatch(/profile\s+Manage hosted browser profiles/);
         expect(stdout.text()).toContain('--profile <name>');
         expect(stdout.text()).toContain('Local-only commands:');
         expect(stdout.text()).toContain('Run `webcmd setup` and choose local mode to use local-only commands.');
@@ -160,6 +161,6 @@ describe('hosted manifest helpers', () => {
             stdout: stdout.stream,
             fetchImpl: async () => new Response(JSON.stringify({ ok: true, manifest }), { status: 200 }),
         });
-        expect(stdout.text().trim().split('\n')).toEqual(['browser', 'completion', 'github', 'list', 'setup']);
+        expect(stdout.text().trim().split('\n')).toEqual(['browser', 'completion', 'github', 'list', 'profile', 'setup']);
     });
 });

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

@@ -156,6 +156,13 @@ const generatedTerminalCorpus = profileForms.flatMap(profile => dispatchForms.fl
     { name: `${profile.name}/clustered-version/${dispatch.name}`, argv: [...profile.tokens, '-Vx', ...dispatch.tokens], kind: 'version' },
 ]));
 describe('hosted root command surface', () => {
+    it('advertises hosted profile management as a root command, not a local-only namespace', () => {
+        expect(HOSTED_ROOT_HELP.commands).toContainEqual({
+            name: 'profile',
+            description: 'Manage hosted browser profiles',
+        });
+        expect(HOSTED_ROOT_HELP.localOnlyCommands?.some(command => command.name === 'profile')).toBe(false);
+    });
     it.each([
         { name: 'no args', argv: [], expected: { kind: 'help', exitCode: 1 } },
         { name: 'profile only', argv: ['--profile', 'work'], expected: { kind: 'help', exitCode: 1 } },

package/dist/src/hosted/runner.js

@@ -15,7 +15,7 @@ import { StreamWriteError, writeToStream } from '../stream-write.js';
 import { PKG_VERSION } from '../version.js';
 import { getCompletionScriptFast } from '../completion-fast.js';
 import { browserCommandCatalog } from '../browser/command-catalog.js';
-import { HostedClient, HostedClientError } from './client.js';
+import { HostedClient, HostedClientError, resolveWorkspace } from './client.js';
 import { parseHostedInvocation } from './args.js';
 import { HostedBrowserHelp, parseHostedBrowserStructure } from './browser-args.js';
 import { materializeHostedOutputs, prepareHostedFiles, rewriteHostedOutputResultPaths } from './files.js';
@@ -53,6 +53,7 @@ export async function runHostedCli(argv, opts = {}) {
         const client = new HostedClient({
             apiBaseUrl: config.hosted.apiBaseUrl,
             apiKey: credential.apiKey,
+            workspace: resolveWorkspace(argv, opts.env ?? process.env),
             fetchImpl: opts.fetchImpl,
         });
         await dispatchHosted(argv, client, stdout, stderr, opts.now ?? Date.now);
@@ -146,6 +147,18 @@ async function dispatchHosted(argv, client, stdout, stderr, now) {
         await renderHostedList(manifest, parsed.format, parsed.formatExplicit, stdout);
         return;
     }
+    if (args[0] === 'profile') {
+        if (args[1] === 'rename' || args[1] === 'use') {
+            throw new ConfigError(`webcmd profile ${args[1]} is not available in hosted mode.`, 'Hosted mode supports: webcmd profile list and delete.');
+        }
+        const parsed = parseHostedProfileSurface(args.slice(1), normalized.literal);
+        if (parsed.kind === 'help') {
+            await writeToStream(stdout, parsed.output);
+            return;
+        }
+        await dispatchHostedProfile(parsed, client, stdout);
+        return;
+    }
     const manifest = await client.getManifest();
     validateManifestContractIdentity(manifest);
     const site = args[0];
@@ -552,6 +565,58 @@ function parseHostedListSurface(argv, literal) {
         throw new CommanderStructuralError("error: command 'list' did not run\n", 1);
     return { kind: 'run', format: parsedFormat, formatExplicit };
 }
+function parseHostedProfileSurface(argv, literal) {
+    let stdout = '';
+    let stderr = '';
+    let parsed;
+    const root = new Command('webcmd');
+    const profile = root.command('profile').description('Manage hosted browser profiles');
+    const output = {
+        writeOut: (value) => { stdout += value; },
+        writeErr: (value) => { stderr += value; },
+    };
+    root.exitOverride().configureOutput(output);
+    profile.exitOverride().configureOutput(output);
+    const configureFormat = (command) => command.option('-f, --format <fmt>', 'Output format: table, json, yaml, md, csv', 'table');
+    const setParsed = (command, surface, value) => {
+        const options = surface.opts();
+        parsed = {
+            kind: 'run',
+            command,
+            format: options.format,
+            formatExplicit: surface.getOptionValueSource('format') === 'cli',
+            ...(value !== undefined ? { value } : {}),
+        };
+    };
+    const list = configureFormat(profile.command('list'));
+    list.exitOverride().configureOutput(output).action(() => setParsed('list', list));
+    const remove = configureFormat(profile.command('delete').argument('<profile-id>'));
+    remove.exitOverride().configureOutput(output).action((profileId) => setParsed('delete', remove, profileId));
+    try {
+        root.parse(literal ? ['--', 'profile', ...argv] : ['profile', ...argv], { from: 'user' });
+    }
+    catch (error) {
+        if (!(error instanceof CommanderError))
+            throw error;
+        if (error.code === 'commander.helpDisplayed')
+            return { kind: 'help', output: stdout };
+        throw new CommanderStructuralError(stderr || `${error.message}\n`, error.exitCode);
+    }
+    if (!parsed) {
+        throw new CommanderStructuralError("error: command 'profile' did not run\n", 1);
+    }
+    return parsed;
+}
+async function dispatchHostedProfile(parsed, client, stdout) {
+    const result = parsed.command === 'list'
+        ? (await client.listProfiles()).profiles
+        : await client.deleteProfile(parsed.value);
+    await renderOutput(result, {
+        fmt: parsed.format,
+        fmtExplicit: parsed.formatExplicit,
+        stdout,
+    });
+}
 function parseHostedCompletionSurface(argv, literal) {
     let stdout = '';
     let stderr = '';