@agentrhq/webcmd 0.1.2 → 0.2.1

package/dist/src/browser/page.js

@@ -40,14 +40,16 @@ export class Page extends BasePage {
     windowMode;
     surface;
     siteSession;
+    preferredContextId;
     _idleTimeout;
-    constructor(session, idleTimeout, contextId, windowMode, surface = 'browser', siteSession) {
+    constructor(session, idleTimeout, contextId, windowMode, surface = 'browser', siteSession, preferredContextId) {
         super();
         this.session = session;
         this.contextId = contextId;
         this.windowMode = windowMode;
         this.surface = surface;
         this.siteSession = siteSession;
+        this.preferredContextId = preferredContextId;
         this._idleTimeout = idleTimeout;
     }
     /** Active page identity (targetId), set after navigate and used in all subsequent commands */
@@ -60,6 +62,7 @@ export class Page extends BasePage {
             session: this.session,
             surface: this.surface,
             ...(this.contextId && { contextId: this.contextId }),
+            ...(this.preferredContextId && { preferredContextId: this.preferredContextId }),
             ...(this._idleTimeout != null && { idleTimeout: this._idleTimeout }),
             ...(this.windowMode && { windowMode: this.windowMode }),
             ...(this.siteSession && { siteSession: this.siteSession }),
@@ -71,6 +74,7 @@ export class Page extends BasePage {
             session: this.session,
             surface: this.surface,
             ...(this.contextId && { contextId: this.contextId }),
+            ...(this.preferredContextId && { preferredContextId: this.preferredContextId }),
             ...(this._page !== undefined && { page: this._page }),
             ...(this._idleTimeout != null && { idleTimeout: this._idleTimeout }),
             ...(this.windowMode && { windowMode: this.windowMode }),

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

@@ -8,6 +8,15 @@ export declare function normalizeContextId(value: string | undefined | null): st
 export declare function emptyProfileConfig(): ProfileConfig;
 export declare function loadProfileConfig(): ProfileConfig;
 export declare function saveProfileConfig(config: ProfileConfig): void;
+export type ProfileSelection = {
+    contextId: string;
+    source: 'explicit' | 'preferred';
+};
+export declare function resolveProfileSelection(profile?: string): ProfileSelection | undefined;
+export declare function profileRouteParams(selection: ProfileSelection | undefined): {
+    contextId?: string;
+    preferredContextId?: string;
+};
 export declare function resolveProfileContextId(profile?: string): string | undefined;
 export declare function aliasForContextId(config: ProfileConfig, contextId: string): string | undefined;
 export declare function renameProfile(contextId: string, alias: string): ProfileConfig;

package/dist/src/browser/profile.js

@@ -42,14 +42,25 @@ export function saveProfileConfig(config) {
     fs.mkdirSync(path.dirname(target), { recursive: true });
     fs.writeFileSync(target, JSON.stringify(config, null, 2) + '\n', 'utf-8');
 }
-export function resolveProfileContextId(profile) {
+export function resolveProfileSelection(profile) {
     const config = loadProfileConfig();
-    const requested = normalizeContextId(profile)
-        ?? normalizeContextId(process.env[`${ENV_PREFIX}_PROFILE`])
-        ?? normalizeContextId(config.defaultContextId);
-    if (!requested)
-        return undefined;
-    return config.aliases[requested] ?? requested;
+    const explicit = normalizeContextId(profile) ?? normalizeContextId(process.env[`${ENV_PREFIX}_PROFILE`]);
+    if (explicit)
+        return { contextId: config.aliases[explicit] ?? explicit, source: 'explicit' };
+    const preferred = normalizeContextId(config.defaultContextId);
+    if (preferred)
+        return { contextId: config.aliases[preferred] ?? preferred, source: 'preferred' };
+    return undefined;
+}
+export function profileRouteParams(selection) {
+    if (!selection)
+        return {};
+    return selection.source === 'explicit'
+        ? { contextId: selection.contextId }
+        : { preferredContextId: selection.contextId };
+}
+export function resolveProfileContextId(profile) {
+    return resolveProfileSelection(profile)?.contextId;
 }
 export function aliasForContextId(config, contextId) {
     for (const [alias, id] of Object.entries(config.aliases)) {

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

@@ -26,12 +26,15 @@ export interface BrowserRuntimeCommand {
     timeoutMs?: number;
     /** Daemon command timeout in seconds. Preserves the existing daemon protocol field. */
     timeout?: number;
+    /** Absolute command deadline in epoch milliseconds. Preferred by newer daemons. */
+    deadlineAt?: number;
     cdpMethod?: string;
     cdpParams?: Record<string, unknown>;
     windowMode?: BrowserWindowMode;
     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/browser.test.js

@@ -18,10 +18,10 @@ describe('browser helpers', () => {
         ]);
     });
     it('extracts tab entries from MCP markdown format', () => {
-        const entries = extractTabEntries('- 0: (current) [Playwright MCP extension](chrome-extension://abc/connect.html)\n- 1: [知乎 - 首页](https://www.zhihu.com/)');
+        const entries = extractTabEntries('- 0: (current) [Playwright MCP extension](chrome-extension://abc/connect.html)\n- 1: [Example - Home](https://example.com/)');
         expect(entries).toEqual([
             { index: 0, identity: '(current) [Playwright MCP extension](chrome-extension://abc/connect.html)' },
-            { index: 1, identity: '[知乎 - 首页](https://www.zhihu.com/)' },
+            { index: 1, identity: '[Example - Home](https://example.com/)' },
         ]);
     });
     it('closes only tabs that were opened during the session', () => {

package/dist/src/cli-argv-preprocess.d.ts

@@ -52,9 +52,9 @@ export interface DashPositionalManifestEntry {
     browser?: boolean;
 }
 /**
- * `webcmd boss detail -abc123def` fails because commander parses
+ * `webcmd openreview paper -abc123def` fails because commander parses
  * `-abc123def` as an unknown option rather than the required
- * `<security-id>` positional. BOSS 直聘 securityId tokens are opaque
+ * `<id>` positional. Some adapter identifiers are opaque
  * strings that can legitimately start with `-` (issue #1160), and the
  * same shape can show up in any adapter that takes an opaque-id
  * positional. Insert a `--` separator so commander treats the next

package/dist/src/cli-argv-preprocess.js

@@ -217,9 +217,9 @@ function consumeKnownOption(argv, index, options) {
     return { values: [token], nextIndex: index + 1 };
 }
 /**
- * `webcmd boss detail -abc123def` fails because commander parses
+ * `webcmd openreview paper -abc123def` fails because commander parses
  * `-abc123def` as an unknown option rather than the required
- * `<security-id>` positional. BOSS 直聘 securityId tokens are opaque
+ * `<id>` positional. Some adapter identifiers are opaque
  * strings that can legitimately start with `-` (issue #1160), and the
  * same shape can show up in any adapter that takes an opaque-id
  * positional. Insert a `--` separator so commander treats the next

package/dist/src/cli-argv-preprocess.test.js

@@ -226,70 +226,70 @@ describe('rewriteBrowserArgv', () => {
 import { escapeLeadingDashPositional } from './cli-argv-preprocess.js';
 describe('escapeLeadingDashPositional', () => {
     const manifest = [
-        { site: 'boss', name: 'detail', browser: true, args: [{ name: 'security-id', positional: true, required: true }, { name: 'retry', positional: false, valueRequired: true }] },
-        { site: 'boss', name: 'search', args: [{ name: 'query', positional: true, required: false }, { name: 'limit', positional: false }] },
+        { site: 'openreview', name: 'paper', browser: true, args: [{ name: 'id', positional: true, required: true }, { name: 'retry', positional: false, valueRequired: true }] },
+        { site: 'openreview', name: 'search', args: [{ name: 'query', positional: true, required: false }, { name: 'limit', positional: false }] },
         { site: 'twitter', name: 'follow', args: [{ name: 'username', positional: true, required: true }] },
         { site: 'twitter', name: 'lists', args: [{ name: 'limit', positional: false }] },
     ];
     it('inserts -- before a required positional starting with `-`', () => {
-        expect(escapeLeadingDashPositional(['boss', 'detail', '-abc123def'], manifest))
-            .toEqual(['boss', 'detail', '--', '-abc123def']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '-abc123def'], manifest))
+            .toEqual(['openreview', 'paper', '--', '-abc123def']);
     });
     it('preserves trailing flags after the dash-leading positional', () => {
-        expect(escapeLeadingDashPositional(['boss', 'detail', '-xyz', '-f', 'json'], manifest))
-            .toEqual(['boss', 'detail', '-f', 'json', '--', '-xyz']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '-xyz', '-f', 'json'], manifest))
+            .toEqual(['openreview', 'paper', '-f', 'json', '--', '-xyz']);
     });
     it('preserves attached short option values like commander does', () => {
-        expect(escapeLeadingDashPositional(['boss', 'detail', '-fjson', '-xyz'], manifest))
-            .toEqual(['boss', 'detail', '-fjson', '--', '-xyz']);
-        expect(escapeLeadingDashPositional(['boss', 'detail', '-xyz', '-fjson'], manifest))
-            .toEqual(['boss', 'detail', '-fjson', '--', '-xyz']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '-fjson', '-xyz'], manifest))
+            .toEqual(['openreview', 'paper', '-fjson', '--', '-xyz']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '-xyz', '-fjson'], manifest))
+            .toEqual(['openreview', 'paper', '-fjson', '--', '-xyz']);
     });
     it('handles known options before a dash-leading positional', () => {
-        expect(escapeLeadingDashPositional(['boss', 'detail', '--format', 'json', '--trace=on', '-xyz'], manifest))
-            .toEqual(['boss', 'detail', '--format', 'json', '--trace=on', '--', '-xyz']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '--format', 'json', '--trace=on', '-xyz'], manifest))
+            .toEqual(['openreview', 'paper', '--format', 'json', '--trace=on', '--', '-xyz']);
     });
     it('keeps adapter and browser options parseable when they follow the positional', () => {
-        expect(escapeLeadingDashPositional(['boss', 'detail', '-xyz', '--retry', '2', '--window', 'foreground'], manifest))
-            .toEqual(['boss', 'detail', '--retry', '2', '--window', 'foreground', '--', '-xyz']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '-xyz', '--retry', '2', '--window', 'foreground'], manifest))
+            .toEqual(['openreview', 'paper', '--retry', '2', '--window', 'foreground', '--', '-xyz']);
     });
     it('protects negative numeric positionals too', () => {
-        expect(escapeLeadingDashPositional(['boss', 'detail', '-42'], manifest))
-            .toEqual(['boss', 'detail', '--', '-42']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '-42'], manifest))
+            .toEqual(['openreview', 'paper', '--', '-42']);
     });
     it('leaves unknown dash options untouched instead of hiding them behind --', () => {
-        expect(escapeLeadingDashPositional(['boss', 'detail', '--unknown', 'value'], manifest))
-            .toEqual(['boss', 'detail', '--unknown', 'value']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '--unknown', 'value'], manifest))
+            .toEqual(['openreview', 'paper', '--unknown', 'value']);
     });
     it('does not touch positional values that do not start with -', () => {
-        expect(escapeLeadingDashPositional(['boss', 'detail', 'normal-id'], manifest))
-            .toEqual(['boss', 'detail', 'normal-id']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', 'normal-id'], manifest))
+            .toEqual(['openreview', 'paper', 'normal-id']);
     });
     it('does not touch the recognised short flags -f / -v / -h', () => {
-        expect(escapeLeadingDashPositional(['boss', 'detail', '-f', 'json'], manifest))
-            .toEqual(['boss', 'detail', '-f', 'json']);
-        expect(escapeLeadingDashPositional(['boss', 'detail', '-v'], manifest))
-            .toEqual(['boss', 'detail', '-v']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '-f', 'json'], manifest))
+            .toEqual(['openreview', 'paper', '-f', 'json']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '-v'], manifest))
+            .toEqual(['openreview', 'paper', '-v']);
     });
     it('does not touch long flags (--*)', () => {
-        expect(escapeLeadingDashPositional(['boss', 'detail', '--format', 'json'], manifest))
-            .toEqual(['boss', 'detail', '--format', 'json']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '--format', 'json'], manifest))
+            .toEqual(['openreview', 'paper', '--format', 'json']);
     });
     it('does not touch already-escaped --', () => {
-        expect(escapeLeadingDashPositional(['boss', 'detail', '--', '-already-escaped'], manifest))
-            .toEqual(['boss', 'detail', '--', '-already-escaped']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper', '--', '-already-escaped'], manifest))
+            .toEqual(['openreview', 'paper', '--', '-already-escaped']);
     });
     it('does not touch commands without a required positional', () => {
-        expect(escapeLeadingDashPositional(['boss', 'search', '-something'], manifest))
-            .toEqual(['boss', 'search', '-something']);
+        expect(escapeLeadingDashPositional(['openreview', 'search', '-something'], manifest))
+            .toEqual(['openreview', 'search', '-something']);
         expect(escapeLeadingDashPositional(['twitter', 'lists', '-something'], manifest))
             .toEqual(['twitter', 'lists', '-something']);
     });
     it('works when --profile or another root flag precedes the site', () => {
-        expect(escapeLeadingDashPositional(['--profile', 'work', 'boss', 'detail', '-abc'], manifest))
-            .toEqual(['--profile', 'work', 'boss', 'detail', '--', '-abc']);
+        expect(escapeLeadingDashPositional(['--profile', 'work', 'openreview', 'paper', '-abc'], manifest))
+            .toEqual(['--profile', 'work', 'openreview', 'paper', '--', '-abc']);
     });
-    it('works for any adapter, not just boss', () => {
+    it('works for another adapter with a required positional', () => {
         expect(escapeLeadingDashPositional(['twitter', 'follow', '-someuser'], manifest))
             .toEqual(['twitter', 'follow', '--', '-someuser']);
     });
@@ -298,7 +298,7 @@ describe('escapeLeadingDashPositional', () => {
             .toEqual(['unknown', 'cmd', '-arg']);
     });
     it('returns argv unchanged when argv is too short', () => {
-        expect(escapeLeadingDashPositional(['boss'], manifest)).toEqual(['boss']);
-        expect(escapeLeadingDashPositional(['boss', 'detail'], manifest)).toEqual(['boss', 'detail']);
+        expect(escapeLeadingDashPositional(['openreview'], manifest)).toEqual(['openreview']);
+        expect(escapeLeadingDashPositional(['openreview', 'paper'], manifest)).toEqual(['openreview', 'paper']);
     });
 });