@agentrhq/webcmd 0.2.3 → 0.2.5

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 {};

package/dist/src/plugin-catalog.js

@@ -0,0 +1,178 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getEnabledPlugins, isMonorepo } from './plugin-manifest.js';
+import { findPackageRoot } from './package-paths.js';
+const MODULE_FILE = fileURLToPath(import.meta.url);
+const CATALOG_FILENAME = 'plugin-catalog.json';
+export function getUserPluginCatalogPath(homeDir = os.homedir()) {
+    return path.join(homeDir, '.webcmd', CATALOG_FILENAME);
+}
+export function getPackagedPluginCatalogPath(packageRoot = findPackageRoot(MODULE_FILE)) {
+    return path.join(packageRoot, CATALOG_FILENAME);
+}
+export function readCatalog(options = {}) {
+    const homeDir = options.homeDir ?? os.homedir();
+    const userPath = getUserPluginCatalogPath(homeDir);
+    if (!fs.existsSync(userPath))
+        seedUserCatalog(options.packageRoot, homeDir);
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(userPath, 'utf-8'));
+    }
+    catch (err) {
+        throw new Error(`Malformed plugin catalog at ${userPath}: ${errorMessage(err)}`);
+    }
+    return normalizeCatalog(parsed, userPath);
+}
+export function writeCatalog(catalog, options = {}) {
+    const userPath = getUserPluginCatalogPath(options.homeDir ?? os.homedir());
+    fs.mkdirSync(path.dirname(userPath), { recursive: true });
+    fs.writeFileSync(userPath, `${JSON.stringify(catalog, null, 2)}\n`);
+}
+export function deriveGithubCatalogSource(source) {
+    const parsed = parseGithubSource(source);
+    if (!parsed)
+        throw new Error(`Unsupported catalog source "${source}". Use github:owner/repo.`);
+    const { owner, repo } = parsed;
+    return {
+        id: `${owner}/${repo}`,
+        source,
+        manifestUrl: `https://raw.githubusercontent.com/${owner}/${repo}/main/webcmd-plugin.json`,
+    };
+}
+export async function addCatalogSource(source, options = {}) {
+    const entry = deriveGithubCatalogSource(source);
+    const catalog = readCatalog(options);
+    const duplicate = catalog.sources.find((existing) => (existing.id === entry.id || existing.source === entry.source || existing.manifestUrl === entry.manifestUrl));
+    if (duplicate)
+        throw new Error(`Catalog source already exists: ${duplicate.id}`);
+    const manifest = await fetchManifest(entry, options.fetchJson);
+    validateMarketplaceManifest(manifest, entry.manifestUrl);
+    catalog.sources.push(entry);
+    writeCatalog(catalog, options);
+    return entry;
+}
+export function removeCatalogSource(id, options = {}) {
+    const catalog = readCatalog(options);
+    const index = catalog.sources.findIndex((source) => source.id === id);
+    if (index < 0)
+        throw new Error(`Catalog source not found: ${id}`);
+    const [removed] = catalog.sources.splice(index, 1);
+    writeCatalog(catalog, options);
+    return removed;
+}
+export function flattenPluginManifest(source, manifest) {
+    if (isMonorepo(manifest)) {
+        return getEnabledPlugins(manifest).map(({ name, entry }) => ({
+            name,
+            description: entry.description,
+            version: entry.version,
+            sourceId: source.id,
+            installSource: `${source.source}/${name}`,
+            webcmd: entry.webcmd ?? manifest.webcmd,
+        }));
+    }
+    if (!manifest.name)
+        return [];
+    return [{
+            name: manifest.name,
+            description: manifest.description,
+            version: manifest.version,
+            sourceId: source.id,
+            installSource: source.source,
+            webcmd: manifest.webcmd,
+        }];
+}
+export async function searchCatalogPlugins(catalog, options = {}) {
+    const plugins = [];
+    const errors = [];
+    await Promise.all(catalog.sources.map(async (source) => {
+        try {
+            const manifest = await fetchManifest(source, options.fetchJson);
+            validateMarketplaceManifest(manifest, source.manifestUrl);
+            plugins.push(...flattenPluginManifest(source, manifest));
+        }
+        catch (err) {
+            errors.push({ sourceId: source.id, manifestUrl: source.manifestUrl, message: errorMessage(err) });
+        }
+    }));
+    const query = options.query?.trim().toLowerCase();
+    const filtered = query
+        ? plugins.filter((plugin) => `${plugin.name} ${plugin.description ?? ''}`.toLowerCase().includes(query))
+        : plugins;
+    filtered.sort((a, b) => a.name.localeCompare(b.name));
+    errors.sort((a, b) => a.sourceId.localeCompare(b.sourceId));
+    return { plugins: filtered, errors };
+}
+function seedUserCatalog(packageRoot, homeDir) {
+    const packagedPath = getPackagedPluginCatalogPath(packageRoot);
+    const userPath = getUserPluginCatalogPath(homeDir);
+    if (!fs.existsSync(packagedPath))
+        throw new Error(`Packaged plugin catalog not found: ${packagedPath}`);
+    fs.mkdirSync(path.dirname(userPath), { recursive: true });
+    fs.copyFileSync(packagedPath, userPath);
+}
+function normalizeCatalog(value, filePath) {
+    if (!isRecord(value))
+        throw new Error(`Malformed plugin catalog at ${filePath}: expected object`);
+    if (value.version !== 1)
+        throw new Error(`Malformed plugin catalog at ${filePath}: expected version 1`);
+    if (!Array.isArray(value.sources))
+        throw new Error(`Malformed plugin catalog at ${filePath}: expected sources array`);
+    return {
+        version: 1,
+        sources: value.sources.map((source, index) => normalizeCatalogSource(source, `${filePath} sources[${index}]`)),
+    };
+}
+function normalizeCatalogSource(value, label) {
+    if (!isRecord(value))
+        throw new Error(`Malformed plugin catalog at ${label}: expected object`);
+    if (typeof value.id !== 'string' || !value.id)
+        throw new Error(`Malformed plugin catalog at ${label}: expected id`);
+    if (typeof value.source !== 'string' || !value.source)
+        throw new Error(`Malformed plugin catalog at ${label}: expected source`);
+    if (typeof value.manifestUrl !== 'string' || !value.manifestUrl)
+        throw new Error(`Malformed plugin catalog at ${label}: expected manifestUrl`);
+    const github = parseGithubSource(value.source);
+    return {
+        id: github ? `${github.owner}/${github.repo}` : value.id,
+        source: value.source,
+        manifestUrl: value.manifestUrl,
+    };
+}
+function parseGithubSource(source) {
+    const match = /^github:([\w.-]+)\/([\w.-]+)$/.exec(source);
+    if (!match)
+        return null;
+    return { owner: match[1], repo: match[2] };
+}
+async function fetchManifest(source, fetchJson = defaultFetchJson) {
+    const value = await fetchJson(source.manifestUrl);
+    if (!isRecord(value))
+        throw new Error(`Invalid plugin manifest at ${source.manifestUrl}: expected object`);
+    return value;
+}
+function validateMarketplaceManifest(manifest, manifestUrl) {
+    if (isMonorepo(manifest)) {
+        if (getEnabledPlugins(manifest).length === 0) {
+            throw new Error(`Invalid plugin manifest at ${manifestUrl}: no enabled plugins`);
+        }
+        return;
+    }
+    if (!manifest.name)
+        throw new Error(`Invalid plugin manifest at ${manifestUrl}: missing name or plugins`);
+}
+async function defaultFetchJson(url) {
+    const response = await fetch(url);
+    if (!response.ok)
+        throw new Error(`HTTP ${response.status} ${response.statusText}`.trim());
+    return response.json();
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/src/plugin-catalog.test.js

@@ -0,0 +1,95 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { addCatalogSource, deriveGithubCatalogSource, flattenPluginManifest, getUserPluginCatalogPath, readCatalog, removeCatalogSource, searchCatalogPlugins, } from './plugin-catalog.js';
+describe('plugin catalog', () => {
+    let tmpDir;
+    let packageRoot;
+    let homeDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'webcmd-plugin-catalog-'));
+        packageRoot = path.join(tmpDir, 'package');
+        homeDir = path.join(tmpDir, 'home');
+        fs.mkdirSync(packageRoot, { recursive: true });
+        fs.mkdirSync(homeDir, { recursive: true });
+        fs.writeFileSync(path.join(packageRoot, 'plugin-catalog.json'), JSON.stringify({
+            version: 1,
+            sources: [{
+                    id: 'agentrhq/webcmd',
+                    source: 'github:agentrhq/webcmd',
+                    manifestUrl: 'https://raw.githubusercontent.com/agentrhq/webcmd/main/webcmd-plugin.json',
+                }],
+        }));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('seeds the user catalog from the packaged default', () => {
+        const catalog = readCatalog({ packageRoot, homeDir });
+        expect(catalog.sources).toEqual([{ id: 'agentrhq/webcmd', source: 'github:agentrhq/webcmd', manifestUrl: 'https://raw.githubusercontent.com/agentrhq/webcmd/main/webcmd-plugin.json' }]);
+        expect(fs.existsSync(getUserPluginCatalogPath(homeDir))).toBe(true);
+    });
+    it('derives catalog metadata from github shorthand', () => {
+        expect(deriveGithubCatalogSource('github:other-org/webcmd-travel-plugins')).toEqual({
+            id: 'other-org/webcmd-travel-plugins',
+            source: 'github:other-org/webcmd-travel-plugins',
+            manifestUrl: 'https://raw.githubusercontent.com/other-org/webcmd-travel-plugins/main/webcmd-plugin.json',
+        });
+    });
+    it('adds and removes catalog sources in the user catalog', async () => {
+        const fetchJson = async () => ({ name: 'travel', description: 'Travel tools' });
+        const added = await addCatalogSource('github:other-org/webcmd-travel-plugins', { packageRoot, homeDir, fetchJson });
+        expect(added.id).toBe('other-org/webcmd-travel-plugins');
+        expect(readCatalog({ packageRoot, homeDir }).sources.map((source) => source.id)).toEqual([
+            'agentrhq/webcmd',
+            'other-org/webcmd-travel-plugins',
+        ]);
+        removeCatalogSource('other-org/webcmd-travel-plugins', { packageRoot, homeDir });
+        expect(readCatalog({ packageRoot, homeDir }).sources.map((source) => source.id)).toEqual(['agentrhq/webcmd']);
+    });
+    it('rejects duplicate catalog sources', async () => {
+        const fetchJson = async () => ({ name: 'travel', description: 'Travel tools' });
+        await addCatalogSource('github:other-org/webcmd-travel-plugins', { packageRoot, homeDir, fetchJson });
+        await expect(addCatalogSource('github:other-org/webcmd-travel-plugins', { packageRoot, homeDir, fetchJson })).rejects.toThrow('already exists');
+    });
+    it('flattens monorepo manifests into installable rows', () => {
+        const rows = flattenPluginManifest({
+            id: 'agentrhq/webcmd',
+            source: 'github:agentrhq/webcmd',
+            manifestUrl: 'https://example.com/webcmd-plugin.json',
+        }, {
+            webcmd: '>=0.2.0',
+            plugins: {
+                skyscanner: { path: 'plugins/skyscanner', version: '0.1.0', description: 'Flights', webcmd: '>=0.2.1' },
+                disabled: { path: 'plugins/disabled', disabled: true },
+            },
+        });
+        expect(rows).toEqual([{ name: 'skyscanner', description: 'Flights', version: '0.1.0', sourceId: 'agentrhq/webcmd', installSource: 'github:agentrhq/webcmd/skyscanner', webcmd: '>=0.2.1' }]);
+    });
+    it('flattens single-plugin manifests into installable rows', () => {
+        const rows = flattenPluginManifest({
+            id: 'research-tools',
+            source: 'github:someone/research-tools',
+            manifestUrl: 'https://example.com/webcmd-plugin.json',
+        }, { name: 'research-tools', version: '0.1.0', description: 'Research helpers', webcmd: '>=0.2.0' });
+        expect(rows).toEqual([{ name: 'research-tools', description: 'Research helpers', version: '0.1.0', sourceId: 'research-tools', installSource: 'github:someone/research-tools', webcmd: '>=0.2.0' }]);
+    });
+    it('fetches manifests live and preserves remote errors in search output', async () => {
+        const catalog = {
+            version: 1,
+            sources: [
+                { id: 'ok', source: 'github:ok/repo', manifestUrl: 'https://ok.test/webcmd-plugin.json' },
+                { id: 'bad', source: 'github:bad/repo', manifestUrl: 'https://bad.test/webcmd-plugin.json' },
+            ],
+        };
+        const fetchJson = async (url) => {
+            if (url.includes('bad'))
+                throw new Error('network failed');
+            return { plugins: { flights: { path: 'plugins/flights', description: 'Flight search' } } };
+        };
+        const result = await searchCatalogPlugins(catalog, { query: 'flight', fetchJson });
+        expect(result.plugins.map((plugin) => plugin.name)).toEqual(['flights']);
+        expect(result.errors).toEqual([{ sourceId: 'bad', manifestUrl: 'https://bad.test/webcmd-plugin.json', message: 'network failed' }]);
+    });
+});

package/dist/src/release-notes.d.ts

@@ -1,4 +1,4 @@
-export declare const RELEASE_NOTE_SECTIONS: readonly ["Highlights", "Improvements", "Fixes", "Adapters", "Contributors", "Reverts"];
+export declare const RELEASE_NOTE_SECTIONS: readonly ["Highlights", "Improvements", "Fixes", "Adapters", "Reverts"];
 export type ReleaseNoteSection = typeof RELEASE_NOTE_SECTIONS[number];
 export interface PullRequestLabel {
     name: string;
@@ -36,5 +36,5 @@ export declare function releaseVersionFromTag(tag: string): string;
 export declare function replaceChangelogReleaseNotes(changelog: string, tag: string, notes: string): string;
 export declare function extractPullRequestNumber(message: string): number | null;
 export declare function filterReleasePullRequests(prs: PullRequestDetails[]): PullRequestDetails[];
-export declare function normalizeReleaseNotes(raw: string, contributors: string[]): string;
+export declare function normalizeReleaseNotes(raw: string): string;
 export declare function buildReleaseNotesPrompt(context: ReleaseContext): string;

package/dist/src/release-notes.js

@@ -3,22 +3,29 @@ export const RELEASE_NOTE_SECTIONS = [
     'Improvements',
     'Fixes',
     'Adapters',
-    'Contributors',
     'Reverts',
 ];
 const SQUASH_MERGE_PR_NUMBER_PATTERN = /\(#(?<number>\d+)\)\s*$/;
 const MERGE_COMMIT_PR_NUMBER_PATTERN = /^Merge pull request #(?<number>\d+) /;
 const RELEASE_PLEASE_TITLE_PATTERN = /^chore(?:\([^)]+\))?: release(?:\s|$)/;
-function normalizeHandle(handle) {
-    const trimmed = handle.trim();
-    return trimmed.startsWith('@') ? trimmed.slice(1) : trimmed;
+function isNoChangeContent(content) {
+    const lines = content
+        .split(/\r?\n/)
+        .map((line) => line.trim().replace(/^[-*]\s+/, '').replace(/[.。]+$/, '').trim().toLowerCase())
+        .filter(Boolean);
+    if (lines.length === 0)
+        return true;
+    return lines.every((line) => (line === 'none'
+        || line === 'n/a'
+        || line === 'not applicable'
+        || /^no .*?(?:changes|updates|reverts|fixes|improvements|adapters|highlights)(?: in this release)?$/.test(line)
+        || /^there (?:are|were) no .*?(?:changes|updates|reverts|fixes|improvements|adapters|highlights)(?: in this release)?$/.test(line)));
 }
-function uniqueSortedHandles(handles) {
-    return [...new Set(handles.map(normalizeHandle).filter(Boolean))].sort((left, right) => left.localeCompare(right));
-}
-function formatSectionContent(content) {
+function normalizeSectionContent(content) {
     const trimmed = content?.trim();
-    return trimmed && trimmed.length > 0 ? trimmed : 'None.';
+    if (!trimmed || isNoChangeContent(trimmed))
+        return null;
+    return trimmed;
 }
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -26,7 +33,7 @@ function escapeRegExp(value) {
 function formatReleaseNotesForChangelog(notes) {
     const trimmed = notes.trim();
     if (!trimmed)
-        return '### Highlights\nNone.';
+        return '';
     return trimmed.replace(/^##\s+/gm, '### ');
 }
 export function releaseVersionFromTag(tag) {
@@ -97,16 +104,11 @@ function parseReleaseNoteSections(raw) {
     }
     return sections;
 }
-export function normalizeReleaseNotes(raw, contributors) {
+export function normalizeReleaseNotes(raw) {
     const sections = parseReleaseNoteSections(raw);
-    const normalizedContributors = uniqueSortedHandles(contributors).map((handle) => `- @${handle}`);
-    return RELEASE_NOTE_SECTIONS.map((section) => {
-        if (section === 'Contributors') {
-            const content = normalizedContributors.length > 0 ? normalizedContributors.join('\n') : 'None.';
-            return `## ${section}\n${content}`;
-        }
-        const content = formatSectionContent(sections[section]?.join('\n'));
-        return `## ${section}\n${content}`;
+    return RELEASE_NOTE_SECTIONS.flatMap((section) => {
+        const content = normalizeSectionContent(sections[section]?.join('\n'));
+        return content ? [`## ${section}\n${content}`] : [];
     }).join('\n\n');
 }
 function formatPullRequest(pr) {
@@ -130,11 +132,13 @@ export function buildReleaseNotesPrompt(context) {
         `Write user-facing release notes for ${context.tag}.`,
         `Release range: ${context.previousTag}...${context.currentRef}.`,
         'Use only the supplied pull requests below. Do not invent changes or pull in information from elsewhere.',
-        `Required sections: ${RELEASE_NOTE_SECTIONS.map((section) => `## ${section}`).join(', ')}.`,
-        'Each section must be present in the final notes.',
+        `Allowed sections: ${RELEASE_NOTE_SECTIONS.map((section) => `## ${section}`).join(', ')}.`,
+        'Include only sections that have user-visible changes. Omit empty sections entirely; do not write "None", "N/A", or similar placeholder text.',
+        'Do not include a Contributors section.',
         'In this project, CLI commands and adapters are the same thing. Treat any PR that adds, removes, or changes files under clis/** as an adapter change, even if the PR title says "CLI" instead of "adapter".',
         'Put new site adapters/CLIs, adapter promotions, adapter hardening, adapter output changes, selector/API updates, and site-specific workflow improvements in ## Adapters.',
         'Use ## Improvements for non-adapter product, runtime, CLI, docs, or workflow improvements.',
+        'Use ## Reverts only when the release includes actual reverted changes.',
         '',
         `Pull requests included for this release:`,
         prSummaries,

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

@@ -17,22 +17,39 @@ describe('release notes helpers', () => {
         ];
         expect(filterReleasePullRequests(prs).map((pr) => pr.number)).toEqual([1]);
     });
-    it('normalizes all required sections and fills empty sections with None', () => {
+    it('normalizes only sections with real release-note content', () => {
         const raw = [
             '## Highlights',
             '- Better release notes.',
             '',
+            '## Improvements',
+            'No improvements.',
+            '',
+            '## Adapters',
+            'No adapter changes.',
+            '',
             '## Fixes',
             '- Fixed release fallback.',
+            '',
+            '## Contributors',
+            '- @alice',
+            '',
+            '## Reverts',
+            'There are no reverts in this release.',
         ].join('\n');
-        const normalized = normalizeReleaseNotes(raw, ['alice', 'bob']);
-        for (const section of RELEASE_NOTE_SECTIONS) {
-            expect(normalized).toContain(`## ${section}`);
-        }
-        expect(normalized).toContain('## Adapters\nNone.');
-        expect(normalized).toContain('## Improvements\nNone.');
-        expect(normalized).toContain('## Contributors\n- @alice\n- @bob');
-        expect(normalized).toContain('## Reverts\nNone.');
+        const normalized = normalizeReleaseNotes(raw);
+        expect(RELEASE_NOTE_SECTIONS).toEqual(['Highlights', 'Improvements', 'Fixes', 'Adapters', 'Reverts']);
+        expect(normalized).toBe([
+            '## Highlights',
+            '- Better release notes.',
+            '',
+            '## Fixes',
+            '- Fixed release fallback.',
+        ].join('\n'));
+        expect(normalized).not.toContain('## Improvements');
+        expect(normalized).not.toContain('## Contributors');
+        expect(normalized).not.toContain('## Reverts');
+        expect(normalized).not.toContain('None.');
     });
     it('replaces a matching changelog release entry with generated notes', () => {
         const changelog = [
@@ -91,6 +108,9 @@ describe('release notes helpers', () => {
         expect(prompt).toContain('docs/docs.json');
         expect(prompt).toContain('## Highlights');
         expect(prompt).toContain('## Adapters');
+        expect(prompt).not.toContain('## Contributors');
+        expect(prompt).toContain('Omit empty sections entirely');
+        expect(prompt).toContain('Do not include a Contributors section');
         expect(prompt).toContain('CLI commands and adapters are the same thing');
         expect(prompt).toContain('files under clis/** as an adapter change');
         expect(prompt).toContain('Put new site adapters/CLIs, adapter promotions, adapter hardening');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentrhq/webcmd",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Turn websites, browser sessions, desktop apps, and local tools into deterministic CLI surfaces for humans and AI agents.",
   "engines": {
     "node": ">=20.0.0"
@@ -32,6 +32,7 @@
     "clis/",
     "skills/**",
     "cli-manifest.json",
+    "plugin-catalog.json",
     "scripts/",
     "README.md",
     "LICENSE",

package/plugin-catalog.json

@@ -0,0 +1,10 @@
+{
+  "version": 1,
+  "sources": [
+    {
+      "id": "agentrhq/webcmd",
+      "source": "github:agentrhq/webcmd",
+      "manifestUrl": "https://raw.githubusercontent.com/agentrhq/webcmd/main/webcmd-plugin.json"
+    }
+  ]
+}

package/scripts/generate-release-notes.ts

@@ -193,10 +193,6 @@ async function generateText(prompt: string, model: string, apiKey: string): Prom
   return text;
 }
 
-function contributorHandles(pullRequests: PullRequestDetails[]): string[] {
-  return pullRequests.flatMap((pr) => (pr.author?.login ? [pr.author.login] : []));
-}
-
 function updateChangelog(tag: string | undefined, notesPath: string | undefined, changelogPath: string | undefined, io: Io): number {
   if (!tag || !notesPath) {
     io.writeStderr('Usage: generate-release-notes --update-changelog <tag> <notes-file> [changelog-file]\n');
@@ -249,8 +245,10 @@ export async function runGenerateReleaseNotes(
     const model = env.GEMINI_RELEASE_NOTES_MODEL || DEFAULT_MODEL;
     const prompt = buildReleaseNotesPrompt(context);
     const raw = await (deps.generateText ?? generateText)(prompt, model, apiKey);
-    const normalized = normalizeReleaseNotes(raw, contributorHandles(context.pullRequests));
-    io.writeStdout(`${normalized}\n`);
+    const normalized = normalizeReleaseNotes(raw);
+    if (normalized) {
+      io.writeStdout(`${normalized}\n`);
+    }
     return 0;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);

package/skills/webcmd-adapter-author/SKILL.md

@@ -28,7 +28,7 @@ Continue only when all three answers are yes.
 
 ## Top-Level Decision Tree
 
-**Choose the strategy before writing the adapter.** Every time you reach Step 3 or Step 4, and before writing code, produce a strategy note. Without that note, do not start `clis/<site>/<name>.js`.
+**Choose the strategy before writing the adapter.** Every time you reach Step 3 or Step 4, and before writing code, produce a strategy note. Without that note, do not start an adapter file.
 
 The core question is not whether an API is more elegant than DOM work. The core question is whether the data source has an external contract. Public or official interfaces are usually the most stable. UI/DOM semantics often have a user-visible contract too. Undocumented in-site XHR, GraphQL, or signature endpoints drift the most. Do not move a stable UI/DOM implementation to an uncontracted internal endpoint just to be "API-first."
 
@@ -253,7 +253,7 @@ Check these off step by step:
 - **The `browser:` field determines the `func` signature:** `browser:false -> (args)`, `browser:true -> (page, args)`. If this is reversed, `args` may actually be a debug flag and all external parameters can silently fall back to defaults.
 - Throw the correct typed error for known failures according to [`references/typed-errors.md`](./references/typed-errors.md). **Do not** silently `return []`, **do not** silently `return [{sentinel}]`, and **do not** silently clamp external parameters with `Math.max/min`.
 - **Persistent sessions keep stale DOM between commands.** `siteSession: 'persistent'` shares one tab per site; leftover modals/drawers from the previous command leak into the next one. State-sensitive write commands (checkout flows) should add `freshPage: true` (new tab, same lease — cookies/login/location survive). Verify session-scoped context (login, selected city/date) *before* side effects, and embed such context in URLs/IDs your command emits for sibling commands. See `references/adapter-template.md` and "Persistent Sessions and State Hygiene" in `docs/authoring.mdx`.
-- For private adapters, write `~/.webcmd/clis/<site>/<name>.js` to avoid a build. Copy to `clis/<site>/<name>.js` only when preparing a PR.
+- For private iteration, write `~/.webcmd/clis/<site>/<name>.js` to avoid a build. When the user says to promote a CLI, create a main-repo plugin with `webcmd plugin create <site> --dir plugins/<site>`, copy the real command files into it, delete scaffold sample commands, register it in root `webcmd-plugin.json`, remove the local `~/.webcmd/clis/<site>` shadow, install the plugin, then run `webcmd validate <site>` and smoke commands. See `references/adapter-template.md` for details.
 - Write site memory every round: no memory -> use skill -> produce memory -> next time becomes a five-minute task.
 - **After a site's first command passes verify, stop and ask the user for their use cases before recommending next set of commands.** See Runbook Step 13.
 - **Raw dumps, packet captures, and HTML samples from debugging may only be written to `~/.webcmd/sites/<site>/fixtures/` or `/tmp/`. Never leave `.dbg-*.html`, `raw-*.json`, `sample.*`, or similar temporary files in the repo root, `clis/<site>/`, or the current working directory.**

package/skills/webcmd-adapter-author/references/adapter-template.md

@@ -16,10 +16,32 @@ Write the working file at:
 ~/.webcmd/clis/<site>/<name>.js
 ```
 
-Copy it to the repo only when preparing a PR:
+Promote a community CLI to the main repo as a plugin:
 
-```text
-clis/<site>/<name>.js
+```bash
+webcmd plugin create <site> --dir plugins/<site> --description "<site> commands for Webcmd"
+cp ~/.webcmd/clis/<site>/*.js plugins/<site>/
+rm plugins/<site>/hello.ts plugins/<site>/greet.ts 2>/dev/null || true
+```
+
+Then add `<site>` to the root `webcmd-plugin.json` `plugins` map:
+
+```json
+"<site>": {
+  "path": "plugins/<site>",
+  "version": "0.1.0",
+  "description": "<site> commands for Webcmd",
+  "webcmd": ">=0.2.0"
+}
+```
+
+Before handing off, remove the private shadow and prove the plugin path works:
+
+```bash
+rm -rf ~/.webcmd/clis/<site>
+webcmd plugin install file://$PWD/plugins/<site>
+webcmd validate <site>
+webcmd <site> <command> --help
 ```
 
 ## Minimal Registry Shape

package/skills/webcmd-autofix/SKILL.md

@@ -18,7 +18,7 @@ Hard stops before any code change:
 
 Scope constraint:
 
-- Modify only the file at `adapterSourcePath` in the trace `summary.md` front matter. That path is authoritative and may be `clis/<site>/...` in the repo or `~/.webcmd/clis/<site>/...` for user-local installs.
+- Modify only the file at `adapterSourcePath` in the trace `summary.md` front matter. That path is authoritative and may be `clis/<site>/...` in the repo or `plugins/<site>/...` in a plugin repo or `~/.webcmd/clis/<site>/...` for user-local installs.
 - Never modify `src/`, `extension/`, `tests/`, `package.json`, or `tsconfig.json` during autofix.
 
 Retry budget: maximum **3 repair rounds** per failure. A round is diagnose -> patch -> retry. If 3 rounds do not resolve it, stop and report what was tried.

package/skills/webcmd-usage/SKILL.md

@@ -10,7 +10,7 @@ Webcmd turns websites, Electron desktop apps, and external CLIs into a uniform `
 
 ## The Three Pillars
 
-- **Adapter commands:** `webcmd <site> <command> [...]`. Built-in adapters live in `clis/`; user adapters live in `~/.webcmd/clis/`. Each command has a strategy such as `PUBLIC`, `COOKIE`, `INTERCEPT`, `UI`, or `LOCAL`.
+- **Adapter commands:** `webcmd <site> <command> [...]`. Built-in adapters live in `clis/`; community adapters promoted to the main repo live as plugins under `plugins/`; private iteration adapters live in `~/.webcmd/clis/`. Each command has a strategy such as `PUBLIC`, `COOKIE`, `INTERCEPT`, `UI`, or `LOCAL`.
 - **Browser driving:** `webcmd browser *` subcommands (`open`, `state`, `click`, `type`, `select`, `find`, `extract`, `network`) for ad-hoc interaction when no adapter covers the task. See `webcmd-browser`.
 - **External CLI passthrough:** `webcmd gh`, `webcmd docker`, `webcmd vercel`, and similar wrappers. Manage them with `webcmd external install <name>` or `webcmd external register <name>`.
 
@@ -102,10 +102,13 @@ The error envelope includes a `trace` block pointing at `summary.md`. Patch only
 
 ## Writing An Adapter
 
-Two storage paths:
+Storage paths:
 
 - Private: `~/.webcmd/clis/<site>/<command>.js`
-- Public / PR: `clis/<site>/<command>.js`
+- Public (official bundle): `clis/<site>/<command>.js`
+- Public (community PRs): `plugins/<site>/` plus root `webcmd-plugin.json` registration
+
+The main Webcmd repo is itself a plugin monorepo: promoted community CLIs belong under `plugins/<site>/` and must be registered in the root `webcmd-plugin.json`.
 
 Scaffolding and checks:
 
@@ -126,9 +129,12 @@ webcmd plugin list [-f json]
 webcmd plugin update [name] | --all
 webcmd plugin uninstall <name>
 webcmd plugin create <name>
+webcmd plugin search [query]
 ```
 
-Plugins are third-party extensions pulled from git and separate from the main adapter registry.
+Plugins are installable extensions pulled from git or local paths. Main-repo community CLIs are exposed through the root plugin catalog manifest, not bundled into npm's `clis/` set.
+
+> **Note:** The repository's `plugins/` directory is not shipped in the npm package. Find the required plugin with `webcmd plugin search`, then install its `installSource` with `webcmd plugin install <installSource>`.
 
 ## External CLI Passthrough