@agentrhq/webcmd 0.2.3 → 0.2.5

package/README.md

@@ -258,7 +258,7 @@ webcmd plugin uninstall <name>
 webcmd plugin create <name>
 ```
 
-Use plugins for private company workflows, community adapters, or experiments that are not ready for the built-in registry.
+Use plugins for private company workflows, community adapters, or experiments that are not ready for the built-in registry. This repo is also a plugin monorepo: community CLIs promoted here live under [`plugins/`](./plugins/) and are advertised through [`webcmd-plugin.json`](./webcmd-plugin.json).
 
 ## Writing Adapters
 
@@ -278,7 +278,7 @@ import { cli, Strategy } from '@agentrhq/webcmd/registry';
 import { CommandExecutionError } from '@agentrhq/webcmd/errors';
 ```
 
-Private adapters can live in `~/.webcmd/clis/<site>/<command>.js`; upstream adapters live in [`clis/`](./clis/). For the full authoring workflow, install and use [`webcmd-adapter-author`](./skills/webcmd-adapter-author/SKILL.md).
+Private adapters can live in `~/.webcmd/clis/<site>/<command>.js`; bundled upstream adapters live in [`clis/`](./clis/), while community upstream adapters live as plugins under [`plugins/`](./plugins/). For the full authoring workflow, install and use [`webcmd-adapter-author`](./skills/webcmd-adapter-author/SKILL.md).
 
 ## Configuration
 

package/cli-manifest.json

@@ -16873,16 +16873,25 @@
   {
     "site": "practo",
     "name": "login",
-    "description": "Open Practo login for manual sign-in",
+    "description": "Open Practo login and wait until the browser session is authenticated",
     "access": "write",
     "domain": "www.practo.com",
     "strategy": "cookie",
     "browser": true,
-    "args": [],
+    "args": [
+      {
+        "name": "timeout",
+        "type": "int",
+        "default": 300,
+        "required": false,
+        "help": "Maximum seconds to wait for the user to finish login"
+      }
+    ],
     "columns": [
       "status",
+      "logged_in",
       "site",
-      "message"
+      "name"
     ],
     "type": "js",
     "modulePath": "practo/login.js",

package/clis/practo/login.js

@@ -1,21 +1,48 @@
+import { AuthRequiredError, TimeoutError } from '@agentrhq/webcmd/errors';
 import { cli, Strategy } from '@agentrhq/webcmd/registry';
-import { PRACTO } from './utils.js';
+import { PRACTO, probeIdentity } from './utils.js';
+
+const DEFAULT_TIMEOUT_SECONDS = 300;
+
+function isAuthRequired(error) {
+  return error instanceof AuthRequiredError;
+}
 
 cli({
   site: 'practo',
   name: 'login',
   access: 'write',
-  description: 'Open Practo login for manual sign-in',
+  description: 'Open Practo login and wait until the browser session is authenticated',
   domain: 'www.practo.com',
   strategy: Strategy.COOKIE,
   browser: true,
   navigateBefore: false,
   defaultWindowMode: 'foreground',
   siteSession: 'persistent',
-  args: [],
-  columns: ['status', 'site', 'message'],
-  func: async (page) => {
-    await page.goto(`${PRACTO}/login`);
-    return [{ status: 'opened', site: 'practo', message: 'Finish login in the browser, then run `webcmd practo whoami`.' }];
+  args: [
+    { name: 'timeout', type: 'int', default: DEFAULT_TIMEOUT_SECONDS, help: 'Maximum seconds to wait for the user to finish login' },
+  ],
+  columns: ['status', 'logged_in', 'site', 'name'],
+  func: async (page, kwargs) => {
+    try {
+      const rows = await probeIdentity(page);
+      return [{ status: 'already_logged_in', ...rows[0] }];
+    } catch (error) {
+      if (!isAuthRequired(error)) throw error;
+    }
+
+    await page.goto(`${PRACTO}/login`, { waitUntil: 'none', settleMs: 1500 });
+    const timeout = Number(kwargs.timeout ?? DEFAULT_TIMEOUT_SECONDS);
+    const deadline = Date.now() + timeout * 1000;
+    while (Date.now() < deadline) {
+      await page.wait(2);
+      try {
+        const rows = await probeIdentity(page);
+        return [{ status: 'login_complete', ...rows[0] }];
+      } catch (error) {
+        if (!isAuthRequired(error)) throw error;
+      }
+    }
+    throw new TimeoutError('practo login', timeout, 'Complete Practo login in the browser, then retry.');
   },
 });

package/clis/practo/practo.test.js

@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { ArgumentError } from '@agentrhq/webcmd/errors';
 import { getRegistry } from '@agentrhq/webcmd/registry';
 import './appointment.js';
@@ -124,6 +124,24 @@ describe('practo command registry', () => {
     expect(cancel.args.find((arg) => arg.name === 'confirm')?.type).toBe('boolean');
   });
 
+  it('waits for manual login to complete', async () => {
+    const login = getRegistry().get('practo/login');
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn()
+        .mockResolvedValueOnce({ __error: 'HTTP 401', status: 401 })
+        .mockResolvedValueOnce({ name: 'Ada' }),
+    };
+
+    await expect(login.func(page, { timeout: 1 })).resolves.toEqual([{
+      status: 'login_complete',
+      logged_in: true,
+      site: 'practo',
+      name: 'Ada',
+    }]);
+  });
+
   it('refuses real booking without --confirm true', async () => {
     const book = getRegistry().get('practo/book-confirm');
     await expect(book.func({}, { practice_doctor_id: '859054', time: '2026-07-10 10:30:00' })).rejects.toThrow(ArgumentError);

package/dist/src/browser/daemon-lifecycle.d.ts

@@ -23,8 +23,10 @@ export declare function waitForDaemonStatus(timeoutMs: number): Promise<DaemonSt
 export declare const daemonLifecycleHooks: {
     requestDaemonShutdown: typeof requestDaemonShutdown;
     spawnDaemonProcess: typeof spawnDaemonProcess;
+    signalDaemonProcessTree: typeof signalDaemonProcessTree;
     waitForDaemonStop: typeof waitForDaemonStop;
 };
+export declare function signalDaemonProcessTree(pid: number, signal: NodeJS.Signals): boolean;
 export declare function restartDaemon(opts?: {
     stopTimeoutMs?: number;
     startTimeoutMs?: number;

package/dist/src/browser/daemon-lifecycle.js

@@ -53,8 +53,31 @@ export async function waitForDaemonStatus(timeoutMs) {
 export const daemonLifecycleHooks = {
     requestDaemonShutdown,
     spawnDaemonProcess,
+    signalDaemonProcessTree,
     waitForDaemonStop,
 };
+export function signalDaemonProcessTree(pid, signal) {
+    let signaled = false;
+    if (process.platform !== 'win32') {
+        try {
+            process.kill(-pid, signal);
+            signaled = true;
+        }
+        catch {
+            // Fall back to the daemon PID below.
+        }
+    }
+    if (!signaled) {
+        try {
+            process.kill(pid, signal);
+            signaled = true;
+        }
+        catch {
+            // The process may have already exited; the caller polls the daemon port.
+        }
+    }
+    return signaled;
+}
 export async function restartDaemon(opts = {}) {
     const previousStatus = await fetchDaemonStatus();
     let stopped = previousStatus === null;
@@ -91,13 +114,12 @@ export async function ensureBrowserBridgeReady(opts = {}) {
         if (!portReleased) {
             const stalePid = health.status?.pid;
             if (typeof stalePid === 'number' && Number.isInteger(stalePid) && stalePid > 0) {
-                try {
-                    process.kill(stalePid, 'SIGKILL');
-                }
-                catch {
-                    // EPERM / ESRCH are both resolved by polling the fixed daemon port.
+                daemonLifecycleHooks.signalDaemonProcessTree(stalePid, 'SIGTERM');
+                portReleased = await daemonLifecycleHooks.waitForDaemonStop(1000);
+                if (!portReleased) {
+                    daemonLifecycleHooks.signalDaemonProcessTree(stalePid, 'SIGKILL');
+                    portReleased = await daemonLifecycleHooks.waitForDaemonStop(2000);
                 }
-                portReleased = await daemonLifecycleHooks.waitForDaemonStop(2000);
             }
         }
         if (!portReleased) {

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

@@ -3,6 +3,7 @@ import { launchPersistentContext as cloakLaunchPersistentContext } from 'cloakbr
 import type { BrowserSurface, SiteSessionMode } from '../../protocol.js';
 import { CloakNetworkCapture } from './network.js';
 export type LaunchPersistentContext = typeof cloakLaunchPersistentContext;
+export type RecoverLockedProfile = (userDataDir: string) => Promise<boolean>;
 export interface SessionKeyInput {
     profileId?: string;
     session?: string;
@@ -33,13 +34,16 @@ export interface CloakTabInfo {
 export interface CloakSessionManagerOptions {
     baseDir?: string;
     launchPersistentContext?: LaunchPersistentContext;
+    recoverLockedProfile?: RecoverLockedProfile;
 }
 export declare function resolveLeaseKey(input: SessionKeyInput): string;
 export declare class CloakSessionManager {
     private readonly opts;
     readonly networkCapture: CloakNetworkCapture;
     private readonly launchPersistentContext;
+    private readonly recoverLockedProfile;
     private readonly profiles;
+    private readonly profileLaunches;
     constructor(opts?: CloakSessionManagerOptions);
     profileStatuses(): {
         contextId: string;
@@ -72,6 +76,7 @@ export declare class CloakSessionManager {
     release(input: SessionKeyInput): Promise<void>;
     shutdown(): Promise<void>;
     private getProfileRuntime;
+    private launchProfileRuntime;
     private openEntries;
     private findEntryByPageId;
     private refreshIdleTimer;

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

@@ -68,25 +68,45 @@ describe('runGenerateReleaseNotes', () => {
                 '## Highlights',
                 '- Better summaries.',
                 '',
-                '## Improvements',
-                'None.',
-                '',
-                '## Fixes',
-                'None.',
-                '',
-                '## Adapters',
-                '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 () => {