dsh-agent-plugins-market 0.4.6 → 0.5.0

package/lib/application/catalog.js

@@ -0,0 +1,447 @@
+/**
+ * Catalog application module: the host-authoritative owner of source state,
+ * discovery, install mutations, and coherent suite snapshots.
+ *
+ * The module deliberately keeps the existing filesystem and Git operations
+ * behind one interface while callers migrate from SuiteManager. User and
+ * project snapshots use their own persisted state files and share the same
+ * source-selection and suite-scanning rules.
+ */
+import { mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { repoName } from '../catalog/manifests.js';
+import { discoverSourceList } from '../catalog/source-catalog.js';
+import { discoverSuitesInSource } from '../catalog/suite-scanner.js';
+import { gitClone, gitHead, gitPull, gitRemove } from '../catalog/git.js';
+import { buildMcpStatus } from '../runtime/mcp-status.js';
+import { buildSuiteDetail, readSkillContent } from './details.js';
+import { deriveSourceId, expandHome, isDirectory, resolveProjectRoot, sanitizeId, sourceCheckoutDir, sourcesDir, STATE_FILE_NAME } from '../catalog/paths.js';
+import { loadState, saveState, EMPTY_STATE } from '../model/state.js';
+export class Catalog {
+    options;
+    state = EMPTY_STATE;
+    mutationQueue = Promise.resolve();
+    statePath;
+    headCache = new Map();
+    listeners = new Set();
+    revision = 0;
+    userSnapshot;
+    userSnapshotPromise;
+    /** Latest MCP mount diagnostics (suiteId -> reasons), fed by host reconcile. */
+    mcpDiagnostics = [];
+    toolSnapshotProvider = () => [];
+    constructor(options) {
+        this.options = options;
+        this.statePath = join(options.userRoot, STATE_FILE_NAME);
+    }
+    /** Install the host tool snapshot provider used by the MCP status surface. */
+    setMcpToolSnapshotProvider(provider) {
+        this.toolSnapshotProvider = provider;
+    }
+    /** Subscribe to completed catalog mutations; returns an unsubscribe function. */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    /** Build the flat MCP service inventory for the status surface. */
+    async mcpStatus() {
+        const snapshot = await this.readUserCatalog();
+        return buildMcpStatus(snapshot.suites, this.mcpDiagnostics, this.toolSnapshotProvider());
+    }
+    /** Load persisted user state once at plugin activation. */
+    async load() {
+        this.state = await loadState(this.statePath);
+        this.invalidateSnapshot(false);
+    }
+    get sources() {
+        return this.state.sources;
+    }
+    /** The user-dimension suite root this catalog operates. */
+    get userRoot() {
+        return this.options.userRoot;
+    }
+    /** Read one coherent user-dimension snapshot, reusing in-flight discovery. */
+    async readUserCatalog() {
+        if (this.userSnapshot !== undefined)
+            return this.userSnapshot;
+        this.userSnapshotPromise ??= this.buildSnapshot(this.state, 'user', this.options.userRoot)
+            .then(snapshot => {
+            this.userSnapshot = snapshot;
+            return snapshot;
+        })
+            .finally(() => {
+            this.userSnapshotPromise = undefined;
+        });
+        return this.userSnapshotPromise;
+    }
+    /** Read one coherent project-dimension snapshot for a workspace cwd. */
+    async readProjectCatalog(cwd) {
+        const projectRoot = await resolveProjectRoot(cwd);
+        const state = await loadState(join(projectRoot, STATE_FILE_NAME));
+        return this.buildSnapshot(state, 'project', projectRoot);
+    }
+    /** One suite's full detail for the market detail modal. */
+    async suiteDetail(sourceId, suiteId) {
+        const snapshot = await this.readUserCatalog();
+        const suite = snapshot.suites.find(entry => entry.sourceId === sourceId && entry.id === suiteId);
+        if (suite === undefined)
+            throw new Error(`suite "${suiteId}" not found in source "${sourceId}"`);
+        return buildSuiteDetail(suite, this.state.installed[installKey(sourceId, suiteId)], this.mcpDiagnostics);
+    }
+    /** One skill's full SKILL.md text for the market detail modal. */
+    async skillContent(sourceId, suiteId, skillName) {
+        const snapshot = await this.readUserCatalog();
+        const suite = snapshot.suites.find(entry => entry.sourceId === sourceId && entry.id === suiteId);
+        if (suite === undefined)
+            throw new Error(`suite "${suiteId}" not found in source "${sourceId}"`);
+        return readSkillContent(suite, skillName);
+    }
+    /** The full market overview from one user snapshot. */
+    async overview() {
+        const snapshot = await this.readUserCatalog();
+        const sourceRows = [];
+        for (const source of snapshot.sources) {
+            const inFlight = this.currentSourceState?.sourceId === source.id ? this.currentSourceState : undefined;
+            const checkout = this.sourceCheckoutPath(source);
+            let cloned = false;
+            let lockCommit;
+            let error;
+            if (source.local === true) {
+                cloned = await isDirectory(checkout);
+                if (!cloned)
+                    error = `local source directory ${checkout} is missing`;
+            }
+            else if (inFlight !== undefined) {
+                // A mutation owns this source right now: do not race git against its checkout.
+                cloned = inFlight.cloned || (await isDirectory(checkout));
+                lockCommit = inFlight.head;
+            }
+            else {
+                const cachedHead = this.headCache.get(source.id);
+                if (cachedHead !== undefined && (await isDirectory(checkout))) {
+                    cloned = true;
+                    lockCommit = cachedHead;
+                }
+                else {
+                    try {
+                        lockCommit = await gitHead(checkout);
+                        cloned = true;
+                        this.headCache.set(source.id, lockCommit);
+                    }
+                    catch {
+                        // Not cloned yet or a broken checkout; refresh reports the actionable error.
+                    }
+                }
+            }
+            const sourceSuites = snapshot.suites.filter(suite => suite.sourceId === source.id);
+            sourceRows.push({
+                id: source.id,
+                url: source.url,
+                ...(source.branch === undefined ? {} : { branch: source.branch }),
+                ...(source.local === true ? { local: true } : {}),
+                cloned,
+                ...(lockCommit === undefined ? {} : { lockCommit }),
+                ...(error === undefined ? {} : { error }),
+                suiteIds: sourceSuites.map(suite => suite.id)
+            });
+        }
+        const installed = new Set(Object.keys(this.state.installed));
+        const cards = snapshot.suites.map(suite => ({
+            sourceId: suite.sourceId,
+            suiteId: suite.id,
+            name: suite.manifest.name,
+            version: suite.manifest.version,
+            description: suite.manifest.description,
+            keywords: suite.manifest.keywords ?? [],
+            surfaces: suite.surfaces,
+            enabled: suite.enabled,
+            installed: installed.has(installKey(suite.sourceId, suite.id)),
+            ...(suite.remote === undefined ? {} : { remoteUrl: suite.remote.url }),
+            dimension: suite.dimension,
+            layout: suite.manifest.layout,
+            errors: suite.errors,
+            mcpErrors: this.mcpDiagnostics.filter(diagnostic => diagnostic.suiteId === suite.id).map(diagnostic => `${diagnostic.serverKey}: ${diagnostic.reason}`)
+        }));
+        return {
+            sources: sourceRows,
+            suites: cards,
+            totals: {
+                all: cards.length,
+                installed: cards.filter(card => card.installed).length,
+                enabled: cards.filter(card => card.enabled).length
+            },
+            roots: { user: this.options.userRoot, data: this.options.dataRoot }
+        };
+    }
+    /** Enabled user-dimension suites from one user snapshot. */
+    async enabledUserSuites() {
+        return (await this.readUserCatalog()).enabledSuites;
+    }
+    /** Enabled user- and project-dimension suites for a workspace cwd. */
+    async enabledSuitesForCwd(cwd) {
+        const [user, project] = await Promise.all([this.readUserCatalog(), this.readProjectCatalog(cwd)]);
+        return { user: user.enabledSuites, project: project.enabledSuites };
+    }
+    /** All suites of one dimension. */
+    async suitesForDimension(dimension, dimensionRoot) {
+        const state = dimension === 'user' && dimensionRoot === this.options.userRoot ? this.state : await loadState(join(dimensionRoot, STATE_FILE_NAME));
+        return (await this.buildSnapshot(state, dimension, dimensionRoot)).suites;
+    }
+    /** Add a source and clone it immediately. */
+    async addSource(input) {
+        return this.enqueue(async () => {
+            const baseId = this.uniqueSourceId(deriveSourceId(input.url));
+            const source = {
+                id: baseId,
+                url: input.url,
+                ...(input.branch === undefined ? {} : { branch: input.branch }),
+                ...(input.local === true ? { local: true } : {})
+            };
+            const checkout = this.sourceCheckoutPath(source);
+            if (input.local === true) {
+                if (!(await isDirectory(checkout)))
+                    throw new Error(`local source directory ${checkout} is missing`);
+            }
+            else {
+                this.beginSourceState(baseId, 'cloning', false);
+                try {
+                    await this.ensureClone(source);
+                }
+                catch (error) {
+                    this.endSourceState();
+                    throw error;
+                }
+                this.updateSourceStep('reading');
+            }
+            source.id = this.uniqueSourceId(sanitizeId(await repoName(checkout)));
+            const head = await tryHead(checkout);
+            if (head !== undefined)
+                this.headCache.set(source.id, head);
+            this.endSourceState();
+            this.state = { ...this.state, sources: [...this.state.sources, source] };
+            await saveState(this.statePath, this.state);
+            this.notifyChanged();
+            return source;
+        });
+    }
+    /** Progress snapshot of the source mutation currently in flight. */
+    currentSourceState;
+    /** Begin reporting progress for a source mutation. */
+    beginSourceState(sourceId, step, cloned) {
+        this.currentSourceState = { sourceId, step, cloned };
+    }
+    /** Advance the in-flight source mutation step. */
+    updateSourceStep(step) {
+        if (this.currentSourceState !== undefined)
+            this.currentSourceState = { ...this.currentSourceState, step };
+    }
+    /** Stop reporting source mutation progress. */
+    endSourceState() {
+        this.currentSourceState = undefined;
+    }
+    /** Progress snapshot for the progress route. */
+    sourceProgress() {
+        const state = this.currentSourceState;
+        return state === undefined ? { active: false, sourceId: '', step: '' } : { active: true, sourceId: state.sourceId, step: state.step };
+    }
+    uniqueSourceId(derived) {
+        if (!this.state.sources.some(source => source.id === derived))
+            return derived;
+        for (let suffix = 2;; suffix++) {
+            const candidate = `${derived}-${suffix}`;
+            if (!this.state.sources.some(source => source.id === candidate))
+                return candidate;
+        }
+    }
+    /** Update one source's URL, branch, or local flag. */
+    async updateSource(sourceId, patch) {
+        return this.enqueue(async () => {
+            const index = this.state.sources.findIndex(source => source.id === sourceId);
+            if (index === -1)
+                throw new Error(`unknown source "${sourceId}"`);
+            const current = this.state.sources[index];
+            const next = {
+                id: sourceId,
+                url: patch.url ?? current.url,
+                ...(patch.branch !== undefined ? { branch: patch.branch } : current.branch === undefined ? {} : { branch: current.branch }),
+                ...(patch.local !== undefined ? { local: patch.local } : current.local === undefined ? {} : { local: current.local })
+            };
+            if (current.local !== true && patch.url !== undefined && patch.url !== current.url) {
+                this.headCache.delete(sourceId);
+                await gitRemove(sourceCheckoutDir(this.options.userRoot, sourceId));
+            }
+            this.state = { ...this.state, sources: this.state.sources.map((source, i) => (i === index ? next : source)) };
+            await saveState(this.statePath, this.state);
+            this.notifyChanged();
+        });
+    }
+    /** Remove a source, its install entries, and its managed checkout. */
+    async removeSource(sourceId) {
+        return this.enqueue(async () => {
+            const source = this.state.sources.find(entry => entry.id === sourceId);
+            this.state = {
+                ...this.state,
+                sources: this.state.sources.filter(entry => entry.id !== sourceId),
+                installed: Object.fromEntries(Object.entries(this.state.installed).filter(([key]) => !key.startsWith(`${sourceId}/`)))
+            };
+            await saveState(this.statePath, this.state);
+            this.headCache.delete(sourceId);
+            if (source === undefined || source.local !== true)
+                await gitRemove(sourceCheckoutDir(this.options.userRoot, sourceId));
+            this.notifyChanged();
+        });
+    }
+    /** Refresh one source checkout, or every source when sourceId is omitted. */
+    async refreshSource(sourceId) {
+        return this.enqueue(async () => {
+            const targets = sourceId === undefined ? this.state.sources : this.state.sources.filter(source => source.id === sourceId);
+            for (const source of targets) {
+                if (source.local === true) {
+                    if (!(await isDirectory(expandHome(source.url))))
+                        throw new Error(`local source directory ${expandHome(source.url)} is missing`);
+                    continue;
+                }
+                const checkout = sourceCheckoutDir(this.options.userRoot, source.id);
+                this.headCache.delete(source.id);
+                try {
+                    await gitHead(checkout);
+                }
+                catch {
+                    await this.ensureClone(source);
+                    try {
+                        this.headCache.set(source.id, await gitHead(checkout));
+                    }
+                    catch {
+                        // A failed HEAD read means the next overview re-probes.
+                    }
+                    continue;
+                }
+                await gitPull(checkout);
+                try {
+                    this.headCache.set(source.id, await gitHead(checkout));
+                }
+                catch {
+                    // A failed HEAD read means the next overview re-probes.
+                }
+            }
+            this.notifyChanged();
+        });
+    }
+    /** Install a suite from a source and enable it. */
+    async install(sourceId, suiteId) {
+        return this.enqueue(async () => {
+            const source = this.state.sources.find(entry => entry.id === sourceId);
+            if (source === undefined)
+                throw new Error(`unknown source "${sourceId}"`);
+            const checkout = this.sourceCheckoutPath(source);
+            if (!(await isDirectory(checkout)))
+                await this.ensureClone(source);
+            const suites = await discoverSuitesInSource(checkout, sourceId, 'user');
+            const suite = suites.find(entry => entry.id === suiteId);
+            if (suite === undefined)
+                throw new Error(`suite "${suiteId}" not found in source "${sourceId}"`);
+            if (suite.remote !== undefined)
+                throw new Error(`suite "${suiteId}" is a remote reference (${suite.remote.url}); add its repository as a source before installing`);
+            await this.setInstalled(sourceId, suiteId, { enabled: true, installedAt: new Date().toISOString(), lockCommit: await tryHead(checkout) });
+            this.notifyChanged();
+        });
+    }
+    /** Uninstall a suite while retaining the source checkout. */
+    async uninstall(sourceId, suiteId) {
+        return this.enqueue(async () => {
+            const key = installKey(sourceId, suiteId);
+            if (this.state.installed[key] === undefined)
+                throw new Error(`suite "${suiteId}" is not installed`);
+            const rest = Object.fromEntries(Object.entries(this.state.installed).filter(([entryKey]) => entryKey !== key));
+            this.state = { ...this.state, installed: rest };
+            await saveState(this.statePath, this.state);
+            this.notifyChanged();
+        });
+    }
+    /** Enable or disable an installed suite. */
+    async setEnabled(sourceId, suiteId, enabled) {
+        return this.enqueue(async () => {
+            const key = installKey(sourceId, suiteId);
+            const entry = this.state.installed[key];
+            if (entry === undefined)
+                throw new Error(`suite "${suiteId}" is not installed`);
+            await this.setInstalled(sourceId, suiteId, { ...entry, enabled });
+            this.notifyChanged();
+        });
+    }
+    /** Append config-seeded sources missing from user state and persist them. */
+    async mergeSources(sources) {
+        const existing = new Set(this.state.sources.map(source => source.id));
+        const additions = sources.filter(source => !existing.has(source.id));
+        if (additions.length === 0)
+            return;
+        this.state = { ...this.state, sources: [...this.state.sources, ...additions] };
+        await saveState(this.statePath, this.state);
+        this.invalidateSnapshot(true);
+    }
+    async setInstalled(sourceId, suiteId, entry) {
+        this.state = { ...this.state, installed: { ...this.state.installed, [installKey(sourceId, suiteId)]: entry } };
+        await saveState(this.statePath, this.state);
+    }
+    async ensureClone(source) {
+        if (source.local === true) {
+            if (!(await isDirectory(expandHome(source.url))))
+                throw new Error(`local source directory ${expandHome(source.url)} is missing`);
+            return;
+        }
+        const checkout = sourceCheckoutDir(this.options.userRoot, source.id);
+        await mkdir(sourcesDir(this.options.userRoot), { recursive: true });
+        await gitClone(source.url, source.branch, checkout);
+    }
+    /** The filesystem location of one source. */
+    sourceCheckoutPath(source) {
+        return source.local === true ? expandHome(source.url) : sourceCheckoutDir(this.options.userRoot, source.id);
+    }
+    async buildSnapshot(state, dimension, dimensionRoot) {
+        const discovered = await discoverSourceList(state.sources, dimension, dimensionRoot);
+        const suites = discovered.map(suite => {
+            const installed = state.installed[installKey(suite.sourceId, suite.id)];
+            return {
+                ...suite,
+                enabled: installed?.enabled === true,
+                ...(installed?.lockCommit === undefined ? {} : { lockCommit: installed.lockCommit }),
+                ...(installed?.installedAt === undefined ? {} : { installedAt: installed.installedAt })
+            };
+        });
+        return {
+            revision: this.revision,
+            sources: [...state.sources],
+            suites,
+            enabledSuites: suites.filter(suite => suite.enabled)
+        };
+    }
+    invalidateSnapshot(increment) {
+        if (increment)
+            this.revision++;
+        this.userSnapshot = undefined;
+        this.userSnapshotPromise = undefined;
+    }
+    notifyChanged() {
+        this.invalidateSnapshot(true);
+        this.options.onChanged();
+        for (const listener of this.listeners)
+            listener();
+    }
+    enqueue(operation) {
+        const result = this.mutationQueue.then(operation, operation);
+        this.mutationQueue = result.catch(() => { });
+        return result;
+    }
+}
+function installKey(sourceId, suiteId) {
+    return `${sourceId}/${suiteId}`;
+}
+/** Read a checkout's HEAD when it is a Git repository. */
+async function tryHead(dir) {
+    try {
+        return await gitHead(dir);
+    }
+    catch {
+        return undefined;
+    }
+}

package/lib/application/details.js

@@ -0,0 +1,136 @@
+/** Suite detail and preview projections owned by the application layer. */
+import { readFile } from 'node:fs/promises';
+import { parse as parseYaml } from 'yaml';
+import { discoverLspEntries, listMdFiles } from '../catalog/surfaces.js';
+/** Build the detail response for one normalized suite. */
+export async function buildSuiteDetail(suite, installed, diagnostics) {
+    const remoteUrl = suite.remote?.url;
+    return {
+        sourceId: suite.sourceId,
+        suiteId: suite.id,
+        name: suite.manifest.name,
+        version: suite.manifest.version ?? null,
+        description: suite.manifest.description ?? null,
+        author: suite.manifest.author ?? null,
+        keywords: suite.manifest.keywords ?? [],
+        layout: suite.manifest.layout,
+        dimension: suite.dimension,
+        root: remoteUrl ?? suite.root,
+        remoteUrl: remoteUrl ?? null,
+        installed: installed !== undefined,
+        enabled: installed?.enabled === true,
+        skills: suite.skills.map(skill => ({
+            name: skill.name,
+            description: skill.description,
+            ...(skill.whenToUse === undefined ? {} : { whenToUse: skill.whenToUse }),
+            path: skill.file
+        })),
+        mcpServers: suite.mcp === undefined ? [] : Object.entries(suite.mcp.servers).map(([key, server]) => ({ key, ...server })),
+        hooks: remoteUrl === undefined ? await hooksPreviews(suite.root) : { count: 0, entries: [] },
+        commands: remoteUrl === undefined ? await markdownPreviews(`${suite.root}/commands`) : [],
+        agents: remoteUrl === undefined ? await markdownPreviews(`${suite.root}/agents`) : [],
+        lsp: remoteUrl === undefined ? await lspPreviews(suite.root) : [],
+        errors: suite.errors,
+        mcpErrors: diagnostics.filter(diagnostic => diagnostic.suiteId === suite.id).map(diagnostic => `${diagnostic.serverKey}: ${diagnostic.reason}`)
+    };
+}
+/** Read one skill body from a normalized suite. */
+export async function readSkillContent(suite, skillName) {
+    const skill = suite.skills.find(entry => entry.name === skillName);
+    if (skill === undefined)
+        throw new Error(`skill "${skillName}" not found in suite "${suite.id}"`);
+    let content;
+    try {
+        content = await readFile(skill.file, 'utf8');
+    }
+    catch (error) {
+        throw new Error(`skill file unreadable: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return { name: skill.name, description: skill.description, content, path: skill.file };
+}
+async function readPreview(path, capBytes = 64 * 1024) {
+    const text = await readFile(path, 'utf8');
+    return text.length > capBytes ? `${text.slice(0, capBytes)}\n… (truncated)` : text;
+}
+async function markdownPreviews(dir) {
+    const names = await listMdFiles(dir);
+    const previews = [];
+    for (const name of names) {
+        const file = `${dir}/${name}`;
+        try {
+            const content = await readPreview(file);
+            const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
+            let description;
+            if (match !== null) {
+                const yaml = parseYaml(match[1]);
+                if (typeof yaml === 'object' && yaml !== null) {
+                    const desc = yaml['description'];
+                    if (typeof desc === 'string')
+                        description = desc;
+                }
+            }
+            previews.push({ name: name.slice(0, -3), ...(description === undefined ? {} : { description }), content });
+        }
+        catch {
+            // Unreadable preview files are omitted from the detail response.
+        }
+    }
+    return previews;
+}
+async function hooksPreviews(root) {
+    for (const relative of ['hooks/hooks.json', 'hooks.json']) {
+        let text;
+        try {
+            text = await readFile(`${root}/${relative}`, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(text);
+            if (typeof parsed !== 'object' || parsed === null)
+                continue;
+            const hooks = parsed['hooks'];
+            if (typeof hooks !== 'object' || hooks === null)
+                continue;
+            const entries = [];
+            for (const [event, groups] of Object.entries(hooks)) {
+                if (!Array.isArray(groups))
+                    continue;
+                for (const group of groups) {
+                    if (typeof group !== 'object' || group === null)
+                        continue;
+                    const record = group;
+                    const matcher = typeof record['matcher'] === 'string' ? record['matcher'] : undefined;
+                    const hooksList = record['hooks'];
+                    if (!Array.isArray(hooksList))
+                        continue;
+                    for (const hook of hooksList) {
+                        if (typeof hook !== 'object' || hook === null)
+                            continue;
+                        const hookRecord = hook;
+                        if (typeof hookRecord['command'] === 'string')
+                            entries.push({ event, ...(matcher === undefined ? {} : { matcher }), command: hookRecord['command'] });
+                    }
+                }
+            }
+            return { count: entries.length, entries };
+        }
+        catch {
+            // Unparsable hook files yield zero entries.
+        }
+    }
+    return { count: 0, entries: [] };
+}
+async function lspPreviews(root) {
+    const previews = [];
+    for (const entry of await discoverLspEntries(root)) {
+        try {
+            previews.push({ name: entry.name, content: await readPreview(entry.path) });
+        }
+        catch {
+            // Unreadable LSP files are omitted from the detail response.
+        }
+    }
+    return previews;
+}

package/lib/application/queries.js

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

package/lib/{discovery → catalog}/manifests.js

@@ -17,8 +17,8 @@
  */
 import { readFile, stat } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
-import { sanitizeId } from '../paths.js';
-import { isRecognizedSchema, validatePluginManifest } from '../validate.js';
+import { sanitizeId } from './paths.js';
+import { isRecognizedSchema, validatePluginManifest } from './validate.js';
 /** Dialect precedence: v1 wins over universal over claude over cursor over kimi over codex. */
 const KIND_PRECEDENCE = ['agent-plugin-v1', 'universal', 'claude-code', 'cursor', 'kimi', 'codex'];
 const MANIFEST_PATHS = {
@@ -27,7 +27,7 @@ const MANIFEST_PATHS = {
     'claude-code': join('.claude-plugin', 'plugin.json'),
     cursor: join('.cursor-plugin', 'plugin.json'),
     kimi: join('.kimi-plugin', 'plugin.json'),
-    codex: join('.codex-plugin', 'plugin.json'),
+    codex: join('.codex-plugin', 'plugin.json')
 };
 /** The highest-precedence manifest file a directory carries, if any. */
 export async function detectManifest(dir) {
@@ -73,24 +73,32 @@ export async function readManifest(root, errors, hint) {
         return undefined;
     }
     const record = raw;
-    const problems = candidate.kind === 'agent-plugin-v1'
-        ? await validatePluginManifest(raw)
-        : [];
+    const problems = candidate.kind === 'agent-plugin-v1' ? await validatePluginManifest(raw) : [];
     errors.push(...problems.map(problem => `${candidate.path}: ${problem}`));
     const name = pickString(record.name) ?? hint?.name ?? syntheticManifestName(root);
     const version = pickString(record.version) ?? hint?.version;
     const description = pickString(record.description) ?? hint?.description;
     const author = record.author;
     return {
-        layout: candidate.kind === 'agent-plugin-v1' ? 'agent-plugin-v1' : candidate.kind === 'universal' ? 'universal' : candidate.kind === 'claude-code' ? 'claude-code' : candidate.kind === 'cursor' ? 'cursor' : candidate.kind === 'kimi' ? 'kimi' : 'codex',
+        layout: candidate.kind === 'agent-plugin-v1'
+            ? 'agent-plugin-v1'
+            : candidate.kind === 'universal'
+                ? 'universal'
+                : candidate.kind === 'claude-code'
+                    ? 'claude-code'
+                    : candidate.kind === 'cursor'
+                        ? 'cursor'
+                        : candidate.kind === 'kimi'
+                            ? 'kimi'
+                            : 'codex',
         path: candidate.path,
         id: sanitizeId(name),
         name,
-        ...version === undefined ? {} : { version },
-        ...description === undefined ? {} : { description },
+        ...(version === undefined ? {} : { version }),
+        ...(description === undefined ? {} : { description }),
         ...(author?.name !== undefined ? { author: author.name } : pickString(record.homepage) !== undefined ? { author: pickString(record.homepage) } : {}),
         keywords: Array.isArray(record.keywords) ? record.keywords.filter((entry) => typeof entry === 'string') : [],
-        ...isRecognizedSchema(record.$schema) ? { schemaVersion: record.$schema } : {},
+        ...(isRecognizedSchema(record.$schema) ? { schemaVersion: record.$schema } : {})
     };
 }
 function pickString(value) {
@@ -117,8 +125,8 @@ export async function readMarketplace(checkoutDir) {
             if (!Array.isArray(plugins))
                 continue;
             return {
-                ...typeof record['name'] === 'string' ? { name: record['name'] } : {},
-                entries: plugins,
+                ...(typeof record['name'] === 'string' ? { name: record['name'] } : {}),
+                entries: plugins
             };
         }
         catch {

package/lib/{paths.js → catalog/paths.js}

@@ -72,7 +72,11 @@ export async function isDirectory(path) {
 }
 /** Sanitize a plugin or server id into `[a-z0-9-]` (lowercased). */
 export function sanitizeId(raw) {
-    const cleaned = raw.toLowerCase().replace(/[^a-z0-9_-]+/g, '-').replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, '').replace(/-{2,}/g, '-');
+    const cleaned = raw
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]+/g, '-')
+        .replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, '')
+        .replace(/-{2,}/g, '-');
     return cleaned === '' ? 'unnamed' : cleaned;
 }
 /** Derive a source id from a repository URL or local path: last path segment, `.git` stripped. */