@agentrhq/webcmd 0.2.2 → 0.2.4

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

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import { execFile } from 'node:child_process';
 import { launchPersistentContext as cloakLaunchPersistentContext } from 'cloakbrowser';
 import { normalizeProfileId, resolveCloakProfileDir } from './profiles.js';
 import { CloakNetworkCapture } from './network.js';
@@ -17,10 +18,13 @@ export class CloakSessionManager {
     opts;
     networkCapture = new CloakNetworkCapture();
     launchPersistentContext;
+    recoverLockedProfile;
     profiles = new Map();
+    profileLaunches = new Map();
     constructor(opts = {}) {
         this.opts = opts;
         this.launchPersistentContext = opts.launchPersistentContext ?? cloakLaunchPersistentContext;
+        this.recoverLockedProfile = opts.recoverLockedProfile ?? recoverLockedCloakProfile;
     }
     profileStatuses() {
         return [...this.profiles.entries()].map(([contextId, runtime]) => ({
@@ -235,13 +239,35 @@ export class CloakSessionManager {
         const existing = this.profiles.get(profileId);
         if (existing)
             return existing;
+        const pending = this.profileLaunches.get(profileId);
+        if (pending)
+            return pending;
+        const launch = this.launchProfileRuntime(profileId);
+        this.profileLaunches.set(profileId, launch);
+        try {
+            return await launch;
+        }
+        finally {
+            this.profileLaunches.delete(profileId);
+        }
+    }
+    async launchProfileRuntime(profileId) {
         const userDataDir = resolveCloakProfileDir(profileId, { baseDir: this.opts.baseDir });
         fs.mkdirSync(userDataDir, { recursive: true });
-        const context = await this.launchPersistentContext({
+        const launchOptions = {
             userDataDir,
             headless: false,
             humanize: true,
-        });
+        };
+        let context;
+        try {
+            context = await this.launchPersistentContext(launchOptions);
+        }
+        catch (err) {
+            if (!isProfileAlreadyInUseError(err) || !(await this.recoverLockedProfile(userDataDir)))
+                throw err;
+            context = await this.launchPersistentContext(launchOptions);
+        }
         const runtime = { context, pages: new Map(), lastSeenAt: Date.now() };
         this.profiles.set(profileId, runtime);
         return runtime;
@@ -291,3 +317,91 @@ function requireSession(session) {
         throw new Error('Browser session is required.');
     return normalized;
 }
+function isProfileAlreadyInUseError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return message.includes('Opening in existing browser session')
+        || message.includes('Failed to create a ProcessSingleton for your profile directory');
+}
+async function recoverLockedCloakProfile(userDataDir) {
+    if (process.platform === 'win32')
+        return false;
+    const initial = await findCloakProfileProcesses(userDataDir);
+    if (initial.length === 0)
+        return false;
+    signalPids(initial, 'SIGTERM');
+    if (await waitForProfileProcessesToExit(userDataDir, 2500))
+        return true;
+    signalPids(await findCloakProfileProcesses(userDataDir), 'SIGKILL');
+    return waitForProfileProcessesToExit(userDataDir, 1500);
+}
+async function waitForProfileProcessesToExit(userDataDir, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        if ((await findCloakProfileProcesses(userDataDir)).length === 0)
+            return true;
+    }
+    return (await findCloakProfileProcesses(userDataDir)).length === 0;
+}
+function signalPids(pids, signal) {
+    for (const pid of pids) {
+        try {
+            process.kill(pid, signal);
+        }
+        catch {
+            // Already exited or not signalable; the follow-up poll decides recovery.
+        }
+    }
+}
+async function findCloakProfileProcesses(userDataDir) {
+    const profileDirs = profileDirAliases(userDataDir);
+    const stdout = await psOutput();
+    const pids = [];
+    for (const line of stdout.split('\n')) {
+        const match = line.match(/^\s*(\d+)\s+(.+)$/);
+        if (!match)
+            continue;
+        const pid = Number(match[1]);
+        const command = match[2];
+        if (!Number.isInteger(pid) || pid === process.pid)
+            continue;
+        if (!isCloakBrowserCommand(command))
+            continue;
+        if (!commandUsesProfileDir(command, profileDirs))
+            continue;
+        pids.push(pid);
+    }
+    return [...new Set(pids)];
+}
+function commandUsesProfileDir(command, profileDirs) {
+    for (const dir of profileDirs) {
+        const marker = `--user-data-dir=${dir}`;
+        const index = command.indexOf(marker);
+        if (index < 0)
+            continue;
+        const next = command[index + marker.length];
+        if (next === undefined || /\s/.test(next))
+            return true;
+    }
+    return false;
+}
+function profileDirAliases(userDataDir) {
+    const aliases = new Set([userDataDir]);
+    try {
+        aliases.add(fs.realpathSync.native(userDataDir));
+    }
+    catch {
+        // The launch path is still useful even if realpath cannot resolve it.
+    }
+    return [...aliases];
+}
+function isCloakBrowserCommand(command) {
+    return command.includes('/.cloakbrowser/') || command.includes('\\.cloakbrowser\\');
+}
+function psOutput() {
+    return new Promise((resolve) => {
+        execFile('ps', ['-axo', 'pid=,command='], { encoding: 'utf8', maxBuffer: 10 * 1024 * 1024, timeout: 2000 }, (err, stdout) => {
+            resolve(err ? '' : String(stdout));
+        });
+    });
+}

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

@@ -42,6 +42,42 @@ describe('CloakSessionManager', () => {
         expect(launchPersistentContext).toHaveBeenCalledTimes(1);
         expect(launchPersistentContext.mock.calls[0][0]).toMatchObject({ headless: false });
     });
+    it('coalesces concurrent persistent context launches for the same profile', async () => {
+        const launched = fakeContext();
+        let resolveLaunch;
+        const launchPersistentContext = vi.fn(() => new Promise((resolve) => {
+            resolveLaunch = resolve;
+        }));
+        const manager = new CloakSessionManager({
+            baseDir: '/tmp/webcmd-test',
+            launchPersistentContext,
+        });
+        const firstPage = manager.getPage({ profileId: 'default', session: 'work', surface: 'browser' });
+        const secondPage = manager.getPage({ profileId: 'default', session: 'work', surface: 'browser' });
+        await Promise.resolve();
+        expect(launchPersistentContext).toHaveBeenCalledTimes(1);
+        resolveLaunch(launched.context);
+        const [first, second] = await Promise.all([firstPage, secondPage]);
+        expect(first.context).toBe(launched.context);
+        expect(second.context).toBe(launched.context);
+        expect(first.page).toBe(second.page);
+    });
+    it('clears a stale Cloak profile owner and retries when Chromium reports an existing session', async () => {
+        const launched = fakeContext();
+        const launchPersistentContext = vi.fn()
+            .mockRejectedValueOnce(new Error('browserType.launchPersistentContext: Opening in existing browser session.'))
+            .mockResolvedValueOnce(launched.context);
+        const recoverLockedProfile = vi.fn().mockResolvedValue(true);
+        const manager = new CloakSessionManager({
+            baseDir: '/tmp/webcmd-test',
+            launchPersistentContext,
+            recoverLockedProfile,
+        });
+        const lease = await manager.getPage({ profileId: 'default', session: 'work', surface: 'browser' });
+        expect(lease.context).toBe(launched.context);
+        expect(recoverLockedProfile).toHaveBeenCalledWith(expectedProfileDir('default'));
+        expect(launchPersistentContext).toHaveBeenCalledTimes(2);
+    });
     it('freshPage closes the existing persistent lease page and creates a new one', async () => {
         const makePage = () => ({
             goto: vi.fn().mockResolvedValue(undefined),

package/dist/src/browser.test.js

@@ -196,7 +196,7 @@ describe('BrowserBridge state', () => {
         const bridge = new BrowserBridge();
         await expect(bridge.connect({ timeout: 0.1 })).rejects.toThrow('Stale daemon could not be replaced');
     });
-    it('falls back to SIGKILL when stale daemon refuses graceful shutdown', async () => {
+    it('falls back to process-group SIGKILL when stale daemon refuses graceful shutdown', async () => {
         vi.spyOn(daemonTransport, 'getDaemonHealth').mockResolvedValue({
             state: 'no-runtime',
             status: {
@@ -213,8 +213,10 @@ describe('BrowserBridge state', () => {
         });
         vi.spyOn(daemonLifecycle.daemonLifecycleHooks, 'requestDaemonShutdown').mockResolvedValue(false);
         // Graceful shutdown short-circuits to false (requestDaemonShutdown -> false).
-        // After SIGKILL the port is released, so the second waitForDaemonStop returns true.
-        vi.spyOn(daemonLifecycle.daemonLifecycleHooks, 'waitForDaemonStop').mockResolvedValue(true);
+        // SIGTERM does not release the port; process-group SIGKILL does.
+        vi.spyOn(daemonLifecycle.daemonLifecycleHooks, 'waitForDaemonStop')
+            .mockResolvedValueOnce(false)
+            .mockResolvedValueOnce(true);
         vi.spyOn(daemonLifecycle.daemonLifecycleHooks, 'spawnDaemonProcess').mockReturnValue(null);
         const killSpy = vi.spyOn(process, 'kill').mockImplementation(() => true);
         const bridge = new BrowserBridge();
@@ -222,7 +224,9 @@ describe('BrowserBridge state', () => {
         // no-runtime wait (which times out with `timeout: 0.1`), producing the
         // runtime-not-ready error rather than the stale-daemon error.
         await expect(bridge.connect({ timeout: 0.1 })).rejects.toThrow('Browser runtime is not ready');
-        expect(killSpy).toHaveBeenCalledWith(99999, 'SIGKILL');
+        const signalPid = process.platform === 'win32' ? 99999 : -99999;
+        expect(killSpy).toHaveBeenCalledWith(signalPid, 'SIGTERM');
+        expect(killSpy).toHaveBeenCalledWith(signalPid, 'SIGKILL');
     });
     it('reports stale daemon error when SIGKILL fails to release the port', async () => {
         vi.spyOn(daemonTransport, 'getDaemonHealth').mockResolvedValue({

package/dist/src/cli.js

@@ -2999,6 +2999,102 @@ cli({
         console.log(`  ${plugins.length} plugin(s) installed`);
         console.log();
     });
+    const catalogCmd = pluginCmd
+        .command('catalog')
+        .description('Manage plugin marketplace sources');
+    catalogCmd
+        .command('list')
+        .description('List configured plugin marketplace sources')
+        .option('-f, --format <fmt>', 'Output format: table, json', 'table')
+        .action(async (opts) => {
+        const { readCatalog } = await import('./plugin-catalog.js');
+        try {
+            const catalog = readCatalog();
+            if (opts.format === 'json') {
+                renderOutput(catalog, { fmt: 'json' });
+                return;
+            }
+            renderOutput(catalog.sources, {
+                fmt: opts.format,
+                columns: ['id', 'source', 'manifestUrl'],
+                title: `${CLI_COMMAND}/plugin-catalog`,
+                source: `${CLI_COMMAND} plugin catalog list`,
+            });
+        }
+        catch (err) {
+            console.error(`Error: ${getErrorMessage(err)}`);
+            process.exitCode = EXIT_CODES.GENERIC_ERROR;
+        }
+    });
+    catalogCmd
+        .command('add')
+        .description('Add a plugin marketplace source')
+        .argument('<source>', 'Marketplace source, e.g. github:owner/repo')
+        .option('-f, --format <fmt>', 'Output format: table, json', 'table')
+        .action(async (source, opts) => {
+        const { addCatalogSource } = await import('./plugin-catalog.js');
+        try {
+            const added = await addCatalogSource(source);
+            renderOutput(opts.format === 'json' ? added : [added], {
+                fmt: opts.format,
+                columns: ['id', 'source', 'manifestUrl'],
+                title: `${CLI_COMMAND}/plugin-catalog`,
+                source: `${CLI_COMMAND} plugin catalog add`,
+            });
+        }
+        catch (err) {
+            console.error(`Error: ${getErrorMessage(err)}`);
+            process.exitCode = EXIT_CODES.GENERIC_ERROR;
+        }
+    });
+    catalogCmd
+        .command('remove')
+        .description('Remove a plugin marketplace source')
+        .argument('<id>', 'Catalog source id')
+        .action(async (id) => {
+        const { removeCatalogSource } = await import('./plugin-catalog.js');
+        try {
+            removeCatalogSource(id);
+            console.log(`✅ Catalog source "${id}" removed.`);
+        }
+        catch (err) {
+            console.error(`Error: ${getErrorMessage(err)}`);
+            process.exitCode = EXIT_CODES.GENERIC_ERROR;
+        }
+    });
+    pluginCmd
+        .command('search')
+        .description('Search installable marketplace plugins')
+        .argument('[query]', 'Search query matched against plugin name and description')
+        .option('-f, --format <fmt>', 'Output format: table, json', 'table')
+        .action(async (query, opts) => {
+        const { readCatalog, searchCatalogPlugins } = await import('./plugin-catalog.js');
+        try {
+            const catalog = readCatalog();
+            const result = await searchCatalogPlugins(catalog, { query });
+            if (opts.format === 'json') {
+                renderOutput(result, { fmt: 'json' });
+            }
+            else {
+                for (const err of result.errors) {
+                    console.error(`Warning: ${err.sourceId}: ${err.message}`);
+                }
+                renderOutput(result.plugins, {
+                    fmt: opts.format,
+                    columns: ['name', 'description', 'version', 'sourceId', 'installSource', 'webcmd'],
+                    title: `${CLI_COMMAND}/plugin-search`,
+                    source: `${CLI_COMMAND} plugin search`,
+                });
+            }
+            if (catalog.sources.length > 0 && result.errors.length === catalog.sources.length) {
+                process.exitCode = EXIT_CODES.GENERIC_ERROR;
+            }
+        }
+        catch (err) {
+            console.error(`Error: ${getErrorMessage(err)}`);
+            process.exitCode = EXIT_CODES.GENERIC_ERROR;
+        }
+    });
     pluginCmd
         .command('create')
         .description('Create a new plugin scaffold')

package/dist/src/cli.test.js

@@ -52,7 +52,7 @@ describe('createProgram root help descriptions', () => {
         expect(descriptionFor(program, 'browser')).toContain('verify');
         expect(descriptionFor(program, 'browser')).not.toContain('Browser control');
         expect(descriptionFor(program, 'auth')).toBe('refresh, status');
-        expect(descriptionFor(program, 'plugin')).toBe('create, install, list, uninstall, update');
+        expect(descriptionFor(program, 'plugin')).toBe('catalog, create, install, list, search, uninstall, update');
         expect(descriptionFor(program, 'adapter')).toBe('eject, reset, status');
         expect(descriptionFor(program, 'profile')).toBe('list, rename, use');
         expect(descriptionFor(program, 'daemon')).toBe('restart, status, stop');
@@ -648,7 +648,7 @@ describe('createProgram root help descriptions', () => {
                 description: 'Manage webcmd plugins',
                 namespace_options: [],
             });
-            expect(data.commands.map((cmd) => cmd.name)).toEqual(['create', 'install', 'list', 'uninstall', 'update']);
+            expect(data.commands.map((cmd) => cmd.name)).toEqual(['catalog add', 'catalog list', 'catalog remove', 'create', 'install', 'list', 'search', 'uninstall', 'update']);
             const update = data.commands.find((cmd) => cmd.name === 'update');
             expect(update).toMatchObject({
                 usage: 'webcmd plugin update [name] [options]',

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

@@ -1,4 +1,6 @@
-import { readFileSync } from 'node:fs';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { describe, expect, it, vi } from 'vitest';
 import { loadReleaseContext, runGenerateReleaseNotes } from '../scripts/generate-release-notes.js';
@@ -66,22 +68,45 @@ describe('runGenerateReleaseNotes', () => {
                 '## Highlights',
                 '- Better summaries.',
                 '',
-                '## Improvements',
-                'None.',
-                '',
-                '## Fixes',
-                'None.',
-                '',
-                '## Contributors',
-                '- @alice',
-                '',
-                '## Reverts',
-                'None.',
-                '',
             ].join('\n'),
             stderr: '',
         });
     });
+    it('prints nothing when generated notes only contain empty placeholders', async () => {
+        const { io, read } = createIo();
+        const context = {
+            tag: 'v1.2.3',
+            previousTag: 'v1.2.2',
+            currentRef: 'abcdef1',
+            pullRequests: [
+                {
+                    number: 42,
+                    title: 'chore: no user visible release changes',
+                    author: { login: 'alice' },
+                    labels: [],
+                    files: [],
+                    url: 'https://example.com/42',
+                },
+            ],
+        };
+        const loadContext = vi.fn(async () => context);
+        const generateText = vi.fn(async () => [
+            '## Highlights',
+            'None.',
+            '',
+            '## Reverts',
+            'There are no reverts in this release.',
+            '',
+            '## Contributors',
+            '- @alice',
+        ].join('\n'));
+        const exitCode = await runGenerateReleaseNotes(['node', 'script', 'v1.2.3'], { GEMINI_API_KEY: 'test-key' }, { loadContext, generateText }, io);
+        expect(exitCode).toBe(0);
+        expect(read()).toEqual({
+            stdout: '',
+            stderr: '',
+        });
+    });
     it('swallows generator errors and keeps release-please notes intact', async () => {
         const { io, read } = createIo();
         const loadContext = vi.fn(async () => {
@@ -94,6 +119,52 @@ describe('runGenerateReleaseNotes', () => {
             stderr: 'Gemini release notes failed: gh timed out\n',
         });
     });
+    it('updates the matching changelog entry from an existing notes file', async () => {
+        const { io, read } = createIo();
+        const tempDir = mkdtempSync(join(tmpdir(), 'webcmd-release-notes-'));
+        const notesPath = join(tempDir, 'release-notes.md');
+        const changelogPath = join(tempDir, 'CHANGELOG.md');
+        try {
+            writeFileSync(notesPath, [
+                '## Highlights',
+                '- Better generated notes.',
+                '',
+                '## Adapters',
+                '- Added checkout adapter polish.',
+                '',
+            ].join('\n'));
+            writeFileSync(changelogPath, [
+                '# Changelog',
+                '',
+                '## [0.2.3](https://github.com/agentrhq/webcmd/compare/webcmd-v0.2.2...webcmd-v0.2.3) (2026-07-09)',
+                '',
+                '### Features',
+                '',
+                '* release-please generated note',
+                '',
+                '## [0.2.2](https://github.com/agentrhq/webcmd/compare/webcmd-v0.2.1...webcmd-v0.2.2) (2026-07-08)',
+                '',
+                '### Bug Fixes',
+                '',
+                '* older note',
+                '',
+            ].join('\n'));
+            const exitCode = await runGenerateReleaseNotes(['node', 'script', '--update-changelog', 'webcmd-v0.2.3', notesPath, changelogPath], {}, {}, io);
+            expect(exitCode).toBe(0);
+            expect(read()).toEqual({
+                stdout: `Updated ${changelogPath} for webcmd-v0.2.3\n`,
+                stderr: '',
+            });
+            const changelog = readFileSync(changelogPath, 'utf8');
+            expect(changelog).toContain('### Highlights\n- Better generated notes.');
+            expect(changelog).toContain('### Adapters\n- Added checkout adapter polish.');
+            expect(changelog).not.toContain('release-please generated note');
+            expect(changelog).toContain('* older note');
+        }
+        finally {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
     it('loads bounded PR diffs into release context', async () => {
         const gh = vi.fn((args) => {
             const key = args.join(' ');
@@ -134,6 +205,9 @@ describe('runGenerateReleaseNotes', () => {
     it('keeps npm publish unblocked when enhanced release-note editing fails', () => {
         const workflowPath = fileURLToPath(new URL('../.github/workflows/release.yml', import.meta.url));
         const workflow = readFileSync(workflowPath, 'utf8');
+        expect(workflow.indexOf('- name: Publish to npm')).toBeLessThan(workflow.indexOf('- name: Update changelog with enhanced release notes'));
+        expect(workflow).toContain('npm --silent run generate-release-notes -- --update-changelog');
+        expect(workflow).toContain('git push origin "HEAD:${{ github.ref_name }}"');
         expect(workflow).toMatch(/if gh release edit "\$\{\{ steps\.release\.outputs\.tag_name \}\}" --notes-file "\$RUNNER_TEMP\/release-notes\.md"; then/);
         expect(workflow).toMatch(/Enhanced release notes could not be applied; keeping release-please notes\./);
     });

package/dist/src/plugin-catalog.d.ts

@@ -0,0 +1,46 @@
+import { type PluginManifest } from './plugin-manifest.js';
+export interface PluginCatalogSource {
+    id: string;
+    source: string;
+    manifestUrl: string;
+}
+export interface PluginCatalog {
+    version: 1;
+    sources: PluginCatalogSource[];
+}
+export interface PluginSearchRow {
+    name: string;
+    description?: string;
+    version?: string;
+    sourceId: string;
+    installSource: string;
+    webcmd?: string;
+}
+export interface PluginSearchError {
+    sourceId: string;
+    manifestUrl: string;
+    message: string;
+}
+export interface PluginSearchResult {
+    plugins: PluginSearchRow[];
+    errors: PluginSearchError[];
+}
+type FetchJson = (url: string) => Promise<unknown>;
+interface CatalogOptions {
+    packageRoot?: string;
+    homeDir?: string;
+    fetchJson?: FetchJson;
+}
+export declare function getUserPluginCatalogPath(homeDir?: string): string;
+export declare function getPackagedPluginCatalogPath(packageRoot?: string): string;
+export declare function readCatalog(options?: CatalogOptions): PluginCatalog;
+export declare function writeCatalog(catalog: PluginCatalog, options?: CatalogOptions): void;
+export declare function deriveGithubCatalogSource(source: string): PluginCatalogSource;
+export declare function addCatalogSource(source: string, options?: CatalogOptions): Promise<PluginCatalogSource>;
+export declare function removeCatalogSource(id: string, options?: CatalogOptions): PluginCatalogSource;
+export declare function flattenPluginManifest(source: PluginCatalogSource, manifest: PluginManifest): PluginSearchRow[];
+export declare function searchCatalogPlugins(catalog: PluginCatalog, options?: {
+    query?: string;
+    fetchJson?: FetchJson;
+}): Promise<PluginSearchResult>;
+export {};