@agentrhq/webcmd 0.2.0 → 0.2.1

package/dist/src/browser/profile.test.js

@@ -0,0 +1,44 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { ENV_PREFIX } from '../brand.js';
+import { profileRouteParams, resolveProfileSelection } from './profile.js';
+describe('profile selection', () => {
+    let configDir;
+    beforeEach(() => {
+        configDir = fs.mkdtempSync(path.join(os.tmpdir(), 'webcmd-profile-test-'));
+        vi.stubEnv(`${ENV_PREFIX}_CONFIG_DIR`, configDir);
+        vi.stubEnv(`${ENV_PREFIX}_PROFILE`, '');
+    });
+    afterEach(() => {
+        vi.unstubAllEnvs();
+        fs.rmSync(configDir, { recursive: true, force: true });
+    });
+    function writeConfig(config) {
+        fs.writeFileSync(path.join(configDir, 'browser-profiles.json'), JSON.stringify(config));
+    }
+    it('tags an explicit profile argument as explicit and resolves aliases', () => {
+        writeConfig({ version: 1, aliases: { work: 'profile-work' } });
+        expect(resolveProfileSelection('work')).toEqual({ contextId: 'profile-work', source: 'explicit' });
+    });
+    it('tags WEBCMD_PROFILE as explicit', () => {
+        vi.stubEnv(`${ENV_PREFIX}_PROFILE`, 'profile-env');
+        expect(resolveProfileSelection()).toEqual({ contextId: 'profile-env', source: 'explicit' });
+    });
+    it('tags the persisted config default as preferred', () => {
+        writeConfig({ version: 1, aliases: {}, defaultContextId: 'profile-default' });
+        expect(resolveProfileSelection()).toEqual({ contextId: 'profile-default', source: 'preferred' });
+    });
+    it('explicit argument beats env, and env beats config default', () => {
+        vi.stubEnv(`${ENV_PREFIX}_PROFILE`, 'from-env');
+        writeConfig({ version: 1, aliases: {}, defaultContextId: 'from-config' });
+        expect(resolveProfileSelection('from-arg')).toEqual({ contextId: 'from-arg', source: 'explicit' });
+        expect(resolveProfileSelection()).toEqual({ contextId: 'from-env', source: 'explicit' });
+    });
+    it('maps explicit routes to contextId and preferred routes to preferredContextId', () => {
+        expect(profileRouteParams({ contextId: 'a', source: 'explicit' })).toEqual({ contextId: 'a' });
+        expect(profileRouteParams({ contextId: 'b', source: 'preferred' })).toEqual({ preferredContextId: 'b' });
+        expect(profileRouteParams(undefined)).toEqual({});
+    });
+});

package/dist/src/browser/protocol.d.ts

@@ -34,6 +34,7 @@ export interface BrowserRuntimeCommand {
     idleTimeout?: number;
     frameIndex?: number;
     contextId?: string;
+    preferredContextId?: string;
     profileId?: string;
 }
 export interface BrowserRuntimeResult {

package/dist/src/browser/runtime/local-cloak/actions.js

@@ -10,8 +10,22 @@ class CloakActionError extends Error {
         this.errorHint = errorHint;
     }
 }
-function commandProfileId(command) {
-    return command.profileId ?? command.contextId ?? 'default';
+function commandProfileId(manager, command) {
+    const requested = command.profileId ?? command.contextId;
+    if (requested?.trim())
+        return requested.trim();
+    const preferred = command.preferredContextId?.trim();
+    if (!preferred)
+        return 'default';
+    const active = manager.activeProfileIds();
+    if (active.includes(preferred))
+        return preferred;
+    if (active.length === 1)
+        return active[0];
+    if (active.length > 1) {
+        throw new CloakActionError('profile_required', `Default Cloak profile "${preferred}" is not active and multiple profiles are running; choose one with --profile.`, undefined, 'Run webcmd profile list, then update the default with webcmd profile use <name> or pass --profile <name>.');
+    }
+    return preferred;
 }
 function invalidRequest(command, error) {
     return { id: command.id, ok: false, errorCode: 'invalid_request', error };
@@ -24,7 +38,7 @@ async function resolveLease(manager, command) {
         throw new CloakActionError('stale_page_identity', `Page not found: ${command.page} — stale page identity`);
     }
     return manager.getPage({
-        profileId: commandProfileId(command),
+        profileId: commandProfileId(manager, command),
         session: command.session,
         surface: command.surface,
         siteSession: command.siteSession,
@@ -93,12 +107,12 @@ export async function dispatchCloakAction(manager, command) {
             }
             case 'close-window': {
                 if (command.page) {
-                    const closed = await manager.closePage({ profileId: commandProfileId(command), pageId: command.page });
+                    const closed = await manager.closePage({ profileId: commandProfileId(manager, command), pageId: command.page });
                     return { id: command.id, ok: true, data: { closed: Boolean(closed), page: closed ?? command.page, session: command.session } };
                 }
                 else {
                     await manager.release({
-                        profileId: commandProfileId(command),
+                        profileId: commandProfileId(manager, command),
                         session: command.session,
                         surface: command.surface,
                     });
@@ -108,12 +122,12 @@ export async function dispatchCloakAction(manager, command) {
             case 'tabs': {
                 switch (command.op ?? 'list') {
                     case 'list': {
-                        const tabs = await manager.listPages({ profileId: commandProfileId(command) });
+                        const tabs = await manager.listPages({ profileId: commandProfileId(manager, command) });
                         return { id: command.id, ok: true, data: tabs };
                     }
                     case 'new': {
                         const lease = await manager.newPage({
-                            profileId: commandProfileId(command),
+                            profileId: commandProfileId(manager, command),
                             session: command.session,
                             surface: command.surface,
                             siteSession: command.siteSession,
@@ -123,13 +137,13 @@ export async function dispatchCloakAction(manager, command) {
                         return { id: command.id, ok: true, data: { title: await lease.page.title(), url: lease.page.url() }, page: lease.pageId };
                     }
                     case 'select': {
-                        const lease = await manager.selectPage({ profileId: commandProfileId(command), pageId: command.page, index: command.index });
+                        const lease = await manager.selectPage({ profileId: commandProfileId(manager, command), pageId: command.page, index: command.index });
                         if (!lease)
                             return { id: command.id, ok: false, errorCode: 'runtime_command_failed', error: 'Tab not found' };
                         return { id: command.id, ok: true, data: { selected: true, url: lease.page.url() }, page: lease.pageId };
                     }
                     case 'close': {
-                        const closed = await manager.closePage({ profileId: commandProfileId(command), pageId: command.page, index: command.index });
+                        const closed = await manager.closePage({ profileId: commandProfileId(manager, command), pageId: command.page, index: command.index });
                         if (!closed)
                             return { id: command.id, ok: false, errorCode: 'runtime_command_failed', error: 'Tab not found' };
                         return { id: command.id, ok: true, data: { closed } };
@@ -197,7 +211,7 @@ export async function dispatchCloakAction(manager, command) {
                 }
                 {
                     const lease = await manager.bindPage({
-                        profileId: commandProfileId(command),
+                        profileId: commandProfileId(manager, command),
                         session: command.session,
                         surface: command.surface,
                         siteSession: command.siteSession,

package/dist/src/browser/runtime/local-cloak/session-manager.d.ts

@@ -46,6 +46,7 @@ export declare class CloakSessionManager {
         pending: number;
         lastSeenAt: number;
     }[];
+    activeProfileIds(): string[];
     getPage(input: SessionKeyInput): Promise<CloakPageLease>;
     findPageById(pageId: string, opts?: Pick<SessionKeyInput, 'idleTimeout'>): CloakPageLease | null;
     pageIdFor(page: PlaywrightPage): string | undefined;

package/dist/src/browser/runtime/local-cloak/session-manager.js

@@ -31,6 +31,9 @@ export class CloakSessionManager {
             lastSeenAt: runtime.lastSeenAt,
         }));
     }
+    activeProfileIds() {
+        return [...this.profiles.keys()];
+    }
     async getPage(input) {
         const profileId = normalizeProfileId(input.profileId);
         const session = requireSession(input.session);

package/dist/src/browser/runtime/local-cloak/session-manager.test.js

@@ -1,5 +1,7 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
+import path from 'node:path';
 import { CloakSessionManager } from './session-manager.js';
+import { dispatchCloakAction } from './actions.js';
 function fakeContext() {
     const page = {
         goto: vi.fn().mockResolvedValue(undefined),
@@ -20,6 +22,9 @@ function fakeContext() {
         page,
     };
 }
+function expectedProfileDir(profileId) {
+    return path.join('/tmp/webcmd-test', 'cloak', 'profiles', profileId);
+}
 describe('CloakSessionManager', () => {
     afterEach(() => {
         vi.useRealTimers();
@@ -89,4 +94,86 @@ describe('CloakSessionManager', () => {
         expect(lease.page.close).not.toHaveBeenCalled();
         expect(await manager.listPages({ profileId: 'default' })).toHaveLength(1);
     });
+    it('launches a preferred profile when no Cloak profile is active', async () => {
+        const launched = fakeContext();
+        const launchPersistentContext = vi.fn().mockResolvedValue(launched.context);
+        const manager = new CloakSessionManager({
+            baseDir: '/tmp/webcmd-test',
+            launchPersistentContext,
+        });
+        await dispatchCloakAction(manager, {
+            id: 'cmd-preferred',
+            action: 'navigate',
+            session: 'work',
+            surface: 'browser',
+            url: 'https://example.com/',
+            preferredContextId: 'profile-default',
+        });
+        expect(launchPersistentContext).toHaveBeenCalledTimes(1);
+        expect(launchPersistentContext.mock.calls[0][0].userDataDir).toBe(expectedProfileDir('profile-default'));
+    });
+    it('falls back to the only active profile when the preferred profile is stale', async () => {
+        const launched = fakeContext();
+        const launchPersistentContext = vi.fn().mockResolvedValue(launched.context);
+        const manager = new CloakSessionManager({
+            baseDir: '/tmp/webcmd-test',
+            launchPersistentContext,
+        });
+        await dispatchCloakAction(manager, {
+            id: 'cmd-active',
+            action: 'navigate',
+            session: 'work',
+            surface: 'browser',
+            url: 'https://example.com/',
+            contextId: 'active',
+        });
+        await dispatchCloakAction(manager, {
+            id: 'cmd-stale-default',
+            action: 'navigate',
+            session: 'work',
+            surface: 'browser',
+            url: 'https://example.com/next',
+            preferredContextId: 'stale-default',
+        });
+        expect(launchPersistentContext).toHaveBeenCalledTimes(1);
+        expect(launchPersistentContext.mock.calls[0][0].userDataDir).toBe(expectedProfileDir('active'));
+    });
+    it('asks for an explicit profile when a stale preferred profile meets multiple active profiles', async () => {
+        const launched = fakeContext();
+        const launchPersistentContext = vi.fn().mockResolvedValue(launched.context);
+        const manager = new CloakSessionManager({
+            baseDir: '/tmp/webcmd-test',
+            launchPersistentContext,
+        });
+        await dispatchCloakAction(manager, {
+            id: 'cmd-a',
+            action: 'navigate',
+            session: 'work-a',
+            surface: 'browser',
+            url: 'https://example.com/a',
+            contextId: 'profile-a',
+        });
+        await dispatchCloakAction(manager, {
+            id: 'cmd-b',
+            action: 'navigate',
+            session: 'work-b',
+            surface: 'browser',
+            url: 'https://example.com/b',
+            contextId: 'profile-b',
+        });
+        const result = await dispatchCloakAction(manager, {
+            id: 'cmd-stale',
+            action: 'navigate',
+            session: 'work',
+            surface: 'browser',
+            url: 'https://example.com/',
+            preferredContextId: 'stale-default',
+        });
+        expect(result).toMatchObject({
+            id: 'cmd-stale',
+            ok: false,
+            errorCode: 'profile_required',
+        });
+        expect(launchPersistentContext).toHaveBeenCalledTimes(2);
+    });
 });

package/dist/src/cli.js

@@ -36,7 +36,7 @@ import { daemonRestart, daemonStatus, daemonStop } from './commands/daemon.js';
 import { log } from './logger.js';
 import { bindTab, BrowserCommandError, sendCommand } from './browser/daemon-client.js';
 import { fetchDaemonStatus } from './browser/daemon-transport.js';
-import { aliasForContextId, loadProfileConfig, renameProfile, resolveProfileContextId, setDefaultProfile } from './browser/profile.js';
+import { aliasForContextId, loadProfileConfig, profileRouteParams, renameProfile, resolveProfileSelection, setDefaultProfile } from './browser/profile.js';
 import { formatDaemonVersion, isDaemonStale } from './browser/daemon-version.js';
 import { DEFAULT_BROWSER_CONNECT_TIMEOUT } from './browser/config.js';
 import { CLI_COMMAND } from './brand.js';
@@ -428,7 +428,7 @@ async function resolveStoredBrowserTarget(page, scope) {
     return resolveBrowserTargetInSession(page, defaultPage, { scope, source: 'saved' });
 }
 /** Create a browser page for browser commands. Uses a named browser session for continuity. */
-async function getBrowserPage(session, targetPage, contextId, opts = {}) {
+async function getBrowserPage(session, targetPage, profileSelection, opts = {}) {
     const { BrowserBridge } = await import('./browser/index.js');
     const bridge = new BrowserBridge();
     // Internal GC timeout for browser sessions. Not the per-command runtime timeout.
@@ -438,11 +438,11 @@ async function getBrowserPage(session, targetPage, contextId, opts = {}) {
         timeout: DEFAULT_BROWSER_CONNECT_TIMEOUT,
         session,
         surface: 'browser',
-        ...(contextId && { contextId }),
+        ...profileRouteParams(profileSelection),
         ...(idleTimeout && idleTimeout > 0 && { idleTimeout }),
         windowMode: opts.windowMode ?? getBrowserWindowMode(undefined, 'foreground'),
     });
-    const targetScope = getBrowserScope(session, contextId);
+    const targetScope = getBrowserScope(session, profileSelection?.contextId);
     const resolvedTargetPage = targetPage
         ? await resolveBrowserTargetInSession(page, targetPage, { scope: targetScope, source: 'explicit' })
         : await resolveStoredBrowserTarget(page, targetScope);
@@ -497,9 +497,9 @@ function getBrowserSession(command) {
         return raw.trim();
     throw new Error('<session> is a required positional argument: webcmd browser <session> <command>');
 }
-function getBrowserContextId(command) {
+function getBrowserProfileSelection(command) {
     const raw = getCommandOption(command, 'profile');
-    return resolveProfileContextId(typeof raw === 'string' && raw.trim() ? raw.trim() : undefined);
+    return resolveProfileSelection(typeof raw === 'string' && raw.trim() ? raw.trim() : undefined);
 }
 function getPageSession(page) {
     const session = page.session;
@@ -508,8 +508,11 @@ function getPageSession(page) {
     throw new Error('Browser page is missing a session');
 }
 function getPageScope(page) {
-    const contextId = page.contextId;
-    return getBrowserScope(getPageSession(page), typeof contextId === 'string' && contextId.trim() ? contextId.trim() : undefined);
+    const { contextId, preferredContextId } = page;
+    const selected = typeof contextId === 'string' && contextId.trim()
+        ? contextId.trim()
+        : (typeof preferredContextId === 'string' && preferredContextId.trim() ? preferredContextId.trim() : undefined);
+    return getBrowserScope(getPageSession(page), selected);
 }
 function snapshotMetricText(snapshot) {
     return typeof snapshot === 'string' ? snapshot : JSON.stringify(snapshot, null, 2);
@@ -882,9 +885,9 @@ Examples:
                 const command = args.at(-1) instanceof Command ? args.at(-1) : undefined;
                 const targetPage = getBrowserTargetId(command);
                 const session = getBrowserSession(command);
-                const contextId = getBrowserContextId(command);
+                const profileSelection = getBrowserProfileSelection(command);
                 const windowMode = getBrowserWindowMode(command, 'foreground');
-                page = await getBrowserPage(session, targetPage, contextId, { windowMode });
+                page = await getBrowserPage(session, targetPage, profileSelection, { windowMode });
                 await fn(page, ...args);
             }
             catch (err) {
@@ -933,12 +936,14 @@ Examples:
                 ? optsOrCommand
                 : {};
             const session = getBrowserSession(command);
-            const contextId = getBrowserContextId(command);
+            const profileSelection = getBrowserProfileSelection(command);
+            const contextId = profileSelection?.contextId;
+            const routing = profileRouteParams(profileSelection);
             try {
                 const { BrowserBridge } = await import('./browser/index.js');
                 const bridge = new BrowserBridge();
-                await bridge.connect({ timeout: DEFAULT_BROWSER_CONNECT_TIMEOUT, session, surface: 'browser', ...(contextId && { contextId }) });
-                await fn({ session, contextId }, opts);
+                await bridge.connect({ timeout: DEFAULT_BROWSER_CONNECT_TIMEOUT, session, surface: 'browser', ...routing });
+                await fn({ session, contextId, routing }, opts);
             }
             catch (err) {
                 if (err instanceof BrowserCommandError) {
@@ -956,7 +961,7 @@ Examples:
         .description('Bind an existing Cloak runtime tab to the browser session named by <session>')
         .option('--page <id>', 'Cloak tab page id from `webcmd browser <session> tab list`')
         .option('--index <n>', 'Cloak tab index from `webcmd browser <session> tab list`')
-        .action(browserSessionCommandAction(async ({ session, contextId }, opts) => {
+        .action(browserSessionCommandAction(async ({ session, contextId, routing }, opts) => {
         const page = typeof opts.page === 'string' && opts.page.trim() ? opts.page.trim() : undefined;
         const rawIndex = typeof opts.index === 'string' && opts.index.trim() ? opts.index.trim() : undefined;
         if ((page && rawIndex) || (!page && !rawIndex)) {
@@ -966,14 +971,14 @@ Examples:
             throw new BrowserCommandError('--index must be a non-negative integer.', 'invalid_request');
         }
         const index = rawIndex === undefined ? undefined : Number.parseInt(rawIndex, 10);
-        const data = await bindTab(session, { ...(contextId && { contextId }), ...(page && { page }), ...(index !== undefined && { index }) });
+        const data = await bindTab(session, { ...routing, ...(page && { page }), ...(index !== undefined && { index }) });
         saveBrowserTargetState(undefined, getBrowserScope(session, contextId));
         console.log(JSON.stringify({ session, ...((data && typeof data === 'object') ? data : { data }) }, null, 2));
     }));
     browser.command('unbind')
         .description('Compatibility command; release the Cloak browser session named by <session>')
-        .action(browserSessionCommandAction(async ({ session, contextId }) => {
-        await sendCommand('close-window', { session, surface: 'browser', ...(contextId && { contextId }) });
+        .action(browserSessionCommandAction(async ({ session, contextId, routing }) => {
+        await sendCommand('close-window', { session, surface: 'browser', ...routing });
         saveBrowserTargetState(undefined, getBrowserScope(session, contextId));
         console.log(JSON.stringify({ unbound: true, session }, null, 2));
     }));

package/dist/src/cli.test.js

@@ -1004,7 +1004,7 @@ describe('profile list', () => {
                 runtimeVersion: '1.0.3',
                 pending: 0,
                 memoryMB: 20,
-                port: 19825,
+                port: 9777,
             }),
         });
         const program = createProgram('', '');
@@ -1027,7 +1027,7 @@ describe('profile list', () => {
                 profiles: [],
                 pending: 0,
                 memoryMB: 20,
-                port: 19825,
+                port: 9777,
             }),
         });
         const program = createProgram('', '');

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

@@ -39,7 +39,7 @@ describe('daemonStatus', () => {
             runtimeVersion: '1.6.8',
             pending: 0,
             memoryMB: 64,
-            port: 19825,
+            port: 9777,
         });
         await daemonStatus();
         expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('running'));
@@ -49,7 +49,7 @@ describe('daemonStatus', () => {
         expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('connected'));
         expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('v1.6.8'));
         expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('64 MB'));
-        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('19825'));
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('9777'));
     });
     it('shows disconnected when runtime is not connected', async () => {
         fetchDaemonStatusMock.mockResolvedValue({
@@ -61,7 +61,7 @@ describe('daemonStatus', () => {
             runtimeName: 'fake',
             pending: 0,
             memoryMB: 32,
-            port: 19825,
+            port: 9777,
         });
         await daemonStatus();
         expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('disconnected'));
@@ -77,7 +77,7 @@ describe('daemonStatus', () => {
             runtimeVersion: undefined,
             pending: 0,
             memoryMB: 32,
-            port: 19825,
+            port: 9777,
         });
         await daemonStatus();
         expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('fake connected'));
@@ -105,7 +105,7 @@ describe('daemonStatus runtime label states (#1575)', () => {
             daemonVersion: PKG_VERSION,
             pending: 0,
             memoryMB: 32,
-            port: 19825,
+            port: 9777,
             runtimeName: 'fake',
             ...extra,
         });
@@ -173,7 +173,7 @@ describe('daemonStop', () => {
             runtimeName: 'fake',
             pending: 0,
             memoryMB: 50,
-            port: 19825,
+            port: 9777,
         });
         requestDaemonShutdownMock.mockResolvedValue(true);
         await daemonStop();
@@ -190,7 +190,7 @@ describe('daemonStop', () => {
             runtimeName: 'fake',
             pending: 0,
             memoryMB: 50,
-            port: 19825,
+            port: 9777,
         });
         requestDaemonShutdownMock.mockResolvedValue(false);
         await daemonStop();
@@ -221,7 +221,7 @@ describe('daemonRestart', () => {
             profiles: [{ contextId: 'work', runtimeConnected: true, pending: 0 }],
             pending: 0,
             memoryMB: 50,
-            port: 19825,
+            port: 9777,
         });
         restartDaemonMock.mockResolvedValue({
             previousStatus: { daemonVersion: '1.7.6' },
@@ -237,13 +237,13 @@ describe('daemonRestart', () => {
                 profiles: [{ contextId: 'work', runtimeConnected: true, pending: 0 }],
                 pending: 0,
                 memoryMB: 51,
-                port: 19825,
+                port: 9777,
             },
         });
         await daemonRestart();
         expect(restartDaemonMock).toHaveBeenCalledTimes(1);
         expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('will disconnect 1 browser profile'));
-        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining(`Daemon restarted on port 19825 (v${PKG_VERSION})`));
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining(`Daemon restarted on port 9777 (v${PKG_VERSION})`));
         expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('Runtime connected; 1 profile connected'));
     });
     it('starts a new daemon when none was running', async () => {
@@ -261,11 +261,11 @@ describe('daemonRestart', () => {
                 runtimeName: 'fake',
                 pending: 0,
                 memoryMB: 51,
-                port: 19825,
+                port: 9777,
             },
         });
         await daemonRestart();
-        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining(`Daemon started on port 19825 (v${PKG_VERSION})`));
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining(`Daemon started on port 9777 (v${PKG_VERSION})`));
         expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('Cloak runtime has not connected yet'));
     });
     it('reports failure when the daemon cannot stop', async () => {
@@ -278,7 +278,7 @@ describe('daemonRestart', () => {
             runtimeName: 'fake',
             pending: 0,
             memoryMB: 50,
-            port: 19825,
+            port: 9777,
         });
         restartDaemonMock.mockResolvedValue({
             previousStatus: { daemonVersion: '1.7.6' },

package/dist/src/constants.d.ts

@@ -2,9 +2,8 @@
  * Shared constants used across explore, synthesize, and pipeline modules.
  */
 import { DAEMON_HEADER_NAME } from './brand.js';
-/** Default daemon port for HTTP/WebSocket communication with browser extension */
-export declare const DEFAULT_DAEMON_PORT = 19825;
-export declare function unsupportedDaemonPortEnvMessage(value?: string): string;
+/** Default daemon port for HTTP communication with the browser runtime. */
+export declare const DEFAULT_DAEMON_PORT = 9777;
 export { DAEMON_HEADER_NAME };
 /** URL query params that are volatile/ephemeral and should be stripped from patterns */
 export declare const VOLATILE_PARAMS: Set<string>;

package/dist/src/constants.js

@@ -1,16 +1,9 @@
 /**
  * Shared constants used across explore, synthesize, and pipeline modules.
  */
-import { CLI_COMMAND, DAEMON_HEADER_NAME, ENV_PREFIX, PRODUCT_DISPLAY_NAME } from './brand.js';
-/** Default daemon port for HTTP/WebSocket communication with browser extension */
-export const DEFAULT_DAEMON_PORT = 19825;
-export function unsupportedDaemonPortEnvMessage(value) {
-    const envName = `${ENV_PREFIX}_DAEMON_PORT`;
-    const suffix = value ? ` (received ${value})` : '';
-    return `${envName} is no longer supported${suffix}. ` +
-        `The ${PRODUCT_DISPLAY_NAME} Chrome extension can only connect to localhost:${DEFAULT_DAEMON_PORT}. ` +
-        `Unset ${envName} and rerun ${CLI_COMMAND}.`;
-}
+import { DAEMON_HEADER_NAME } from './brand.js';
+/** Default daemon port for HTTP communication with the browser runtime. */
+export const DEFAULT_DAEMON_PORT = 9777;
 export { DAEMON_HEADER_NAME };
 /** URL query params that are volatile/ephemeral and should be stripped from patterns */
 export const VOLATILE_PARAMS = new Set([

package/dist/src/daemon.js

@@ -1,13 +1,9 @@
-import { DEFAULT_DAEMON_PORT, unsupportedDaemonPortEnvMessage } from './constants.js';
+import { DEFAULT_DAEMON_PORT } from './constants.js';
 import { EXIT_CODES } from './errors.js';
 import { log } from './logger.js';
 import { PKG_VERSION } from './version.js';
 import { createDaemonServer } from './daemon/server.js';
 import { LocalCloakRuntimeProvider } from './browser/runtime/local-cloak/provider.js';
-if (process.env.WEBCMD_DAEMON_PORT) {
-    log.error(unsupportedDaemonPortEnvMessage(process.env.WEBCMD_DAEMON_PORT));
-    process.exit(EXIT_CODES.USAGE_ERROR);
-}
 const provider = new LocalCloakRuntimeProvider();
 const daemon = createDaemonServer(provider, { port: DEFAULT_DAEMON_PORT, host: '127.0.0.1', version: PKG_VERSION });
 daemon.listen().then(() => {

package/dist/src/doctor.js

@@ -93,6 +93,18 @@ export async function runBrowserDoctor(opts = {}) {
     if (!connectivity.ok) {
         issues.push(`Browser connectivity test failed: ${connectivity.error ?? 'unknown'}`);
     }
+    const profileConfig = loadProfileConfig();
+    const staleDefault = profileConfig.defaultContextId;
+    if (staleDefault && profiles?.length && !profiles.some((p) => p.contextId === staleDefault)) {
+        const alias = aliasForContextId(profileConfig, staleDefault);
+        const label = alias ? `${alias} (${staleDefault})` : staleDefault;
+        const fallbackNote = profiles.length === 1
+            ? `Commands currently fall back to the only active profile: ${profiles[0].contextId}.`
+            : 'Multiple profiles are active, so commands will ask you to choose.';
+        issues.push(`Default Cloak profile is not active: ${label}.\n` +
+            `  ${fallbackNote}\n` +
+            '  Refresh it with: webcmd profile list, then webcmd profile use <name>.');
+    }
     if (adapterShadows.length > 0) {
         issues.push(formatAdapterShadowIssue(adapterShadows));
     }

package/dist/src/doctor.test.js

@@ -49,7 +49,7 @@ describe('doctor report rendering', () => {
             runtimeVersion: '1.6.8',
             issues: [],
         }));
-        expect(text).toContain('[OK] Daemon: running on port 19825');
+        expect(text).toContain('[OK] Daemon: running on port 9777');
         expect(text).toContain('(v1.7.9)');
         expect(text).toContain('[OK] Runtime: Cloak connected (v1.6.8)');
         expect(text).toContain('Everything looks good!');
@@ -66,7 +66,7 @@ describe('doctor report rendering', () => {
             runtimeVersion: '1.0.3',
             issues: ['Stale daemon detected: daemon v1.7.6 != CLI v1.7.9.\n  Run: webcmd daemon restart'],
         }));
-        expect(text).toContain('[WARN] Daemon: running on port 19825 (v1.7.6, stale; CLI v1.7.9)');
+        expect(text).toContain('[WARN] Daemon: running on port 9777 (v1.7.6, stale; CLI v1.7.9)');
         expect(text).toContain('Run: webcmd daemon restart');
         expect(text).not.toContain('Everything looks good!');
     });
@@ -86,7 +86,7 @@ describe('doctor report rendering', () => {
             runtimeConnected: false,
             issues: ['Daemon is running but the Cloak runtime is not connected.'],
         }));
-        expect(text).toContain('[OK] Daemon: running on port 19825');
+        expect(text).toContain('[OK] Daemon: running on port 9777');
         expect(text).toContain('[MISSING] Runtime: Cloak not connected');
     });
     it('renders OK when the connected Cloak runtime version is unknown', () => {
@@ -157,6 +157,33 @@ describe('doctor report rendering', () => {
             expect.stringContaining('Daemon is not running'),
         ]));
     });
+    it('reports a stale default Cloak profile when it is not active', async () => {
+        const fs = await import('node:fs');
+        const os = await import('node:os');
+        const path = await import('node:path');
+        const configDir = fs.mkdtempSync(path.join(os.tmpdir(), 'webcmd-doctor-profile-'));
+        fs.writeFileSync(path.join(configDir, 'browser-profiles.json'), JSON.stringify({ version: 1, aliases: { work: 'profile-default' }, defaultContextId: 'profile-default' }));
+        vi.stubEnv('WEBCMD_CONFIG_DIR', configDir);
+        try {
+            mockGetDaemonHealth.mockResolvedValueOnce({
+                state: 'ready',
+                status: {
+                    runtimeConnected: true,
+                    runtimeName: 'Cloak',
+                    profiles: [{ contextId: 'active-profile', runtimeConnected: true, pending: 0 }],
+                },
+            });
+            const report = await runBrowserDoctor();
+            expect(report.issues).toEqual(expect.arrayContaining([
+                expect.stringContaining('Default Cloak profile is not active: work (profile-default)'),
+            ]));
+            expect(report.issues.join('\n')).toContain('fall back to the only active profile: active-profile');
+        }
+        finally {
+            vi.unstubAllEnvs();
+            fs.rmSync(configDir, { recursive: true, force: true });
+        }
+    });
     it('reports flapping when live check succeeds but final status shows runtime disconnected', async () => {
         mockGetDaemonHealth.mockResolvedValueOnce({ state: 'no-runtime', status: { runtimeConnected: false, runtimeName: 'Cloak' } });
         const report = await runBrowserDoctor();