dsh-agent-plugins-market 0.6.2 → 0.7.1

package/lib/index.js

@@ -1,21 +1,24 @@
 import { Catalog } from './application/catalog.js';
+import { settlesWithin } from './runtime/deadline.js';
 import { RuntimeReconciler } from './runtime/reconciler.js';
-import { inspectToolRegistry } from './runtime/tool-registry-observer.js';
+import { ReconcileScheduler } from './runtime/reconcile-scheduler.js';
+import { MarketSettingsNamespace } from './runtime/settings-namespace.js';
+import { deleteMcpAuthGrant } from './runtime/mcp-auth-record.js';
+import { inspectToolRegistry, toolsServiceOf } from './runtime/tool-registry-observer.js';
 import { migratePluginStorage } from './runtime/storage-migration.js';
 import { mountAgentRoleTool } from './runtime/agent-role-router.js';
 import { projectAgentRoles } from './application/project-agent-roles.js';
 import { mountProjectCommands, mountProjectMcp, mountProjectHooks, mountSuiteInstructions } from './runtime/project-runtime.js';
 import { createPanelResources } from './application/panel-resources.js';
-import { resolveDataRoot, resolveUserRoot } from './catalog/paths.js';
+import { resolveAgentsRoot, resolveDataRoot, resolveUserRoot } from './catalog/paths.js';
 import { mountSuiteRoutes } from './routes.js';
-import { MCP_SETTINGS_NAMESPACE, MarketSettingsSchema, readMcpBackend } from './runtime/mcp-backend.js';
-import { narrowDownloadRegion } from './runtime/regions.js';
 import { SuiteSkillProvider } from './runtime/skills-provider.js';
+import { shellSeamOf } from './runtime/dynamic-context.js';
 import { loadLspServers } from './runtime/lsp-direct-config.js';
 import { loadDisabledLspServers } from './runtime/lsp-server-state.js';
-import { bindHostLocale, loadHostLocale } from './runtime/host-locale.js';
-import { mountFeedbackTool } from './runtime/feedback-tool.js';
+import { bindHostLocale, loadHostLocale, readHostLocalePreference, setHostLocaleSource } from './runtime/host-locale.js';
 import { createUserPanelStores } from './runtime/user-panels.js';
+import { SourceAutoUpdater } from './runtime/source-auto-update.js';
 import { UserPanelSkillProvider } from './runtime/user-panels.js';
 import { UserCommandMountRegistry } from './runtime/user-commands.js';
 export const name = 'dsh-agent-plugins-market';
@@ -23,6 +26,7 @@ export const inject = ['skills', 'commands'];
 export async function apply(ctx, config = {}) {
     const userRoot = resolveUserRoot(config.userRoot);
     const dataRoot = resolveDataRoot(config.dataRoot, userRoot);
+    const agentsRoot = resolveAgentsRoot();
     const migration = await migratePluginStorage(config);
     if (migration.conflicts.length > 0)
         throw new Error(`Plugin storage migration conflicts (original files retained): ${migration.conflicts.join(', ')}`);
@@ -30,251 +34,151 @@ export async function apply(ctx, config = {}) {
     let userPanelControl;
     // Host runtime copy resolves from the harness `locale.preference` setting;
     // the async settings read lands before the first session starts in practice.
-    const t = bindHostLocale(undefined);
-    void loadHostLocale().then(locale => {
-        hostLocale.t = locale.t;
-        providerControl?.invalidate();
-        userPanelControl?.invalidate();
+    const hostLocale = { t: bindHostLocale(undefined) };
+    const refreshHostLocale = () => {
+        void loadHostLocale().then(locale => {
+            hostLocale.t = locale.t;
+            providerControl?.invalidate();
+            userPanelControl?.invalidate();
+        });
+    };
+    void refreshHostLocale();
+    // The locale preference the GUI writes is owned by the host settings service:
+    // read it there rather than re-parsing the document, and re-bind once the
+    // service lands (the locale namespace may register after this plugin).
+    ctx.inject(['settings'], settingsCtx => {
+        setHostLocaleSource(() => readHostLocalePreference(settingsCtx));
+        refreshHostLocale();
     });
-    const hostLocale = { t };
-    /** Settings watchers to release at teardown (backend watch + feedback switch). */
-    const settingsWatchers = [];
     const runtime = new RuntimeReconciler(ctx, dataRoot, key => hostLocale.t(key));
     // User panel stores (skills / commands / agent personas) and their runtime
     // contributions: one extra skill provider plus one command mount registry.
-    const panels = createUserPanelStores(userRoot);
+    const panels = createUserPanelStores(agentsRoot);
     const userCommands = new UserCommandMountRegistry(ctx, panels.commands, key => hostLocale.t(key));
     let disposed = false;
     let projectCommands;
     let projectMcp;
     let projectHooks;
     let suitePrompts;
-    let reconcileRequested = false;
-    let reconciliation;
-    const reconcileOnce = async () => {
-        try {
-            const suites = await catalog.enabledUserSuites();
-            if (disposed)
-                return;
-            const diagnostics = await runtime.reconcile(suites);
-            catalog.mcpDiagnostics = diagnostics.mcp;
-            for (const diagnostic of diagnostics.mcp) {
-                ctx.logger?.warn(`[dsh-agent-plugins-market] suite "${diagnostic.suiteId}" mcp server "${diagnostic.serverKey}": ${diagnostic.reason}`);
-            }
-            for (const diagnostic of diagnostics.lsp) {
-                ctx.logger?.warn(`[dsh-agent-plugins-market] suite "${diagnostic.suiteId}" lsp server "${diagnostic.serverKey}": ${diagnostic.reason}`);
-            }
-            for (const diagnostic of diagnostics.commands) {
-                if (diagnostic.reason !== '')
-                    ctx.logger?.warn(`[dsh-agent-plugins-market] suite "${diagnostic.suiteId}" command "${diagnostic.command}": ${diagnostic.reason}`);
-            }
-            for (const diagnostic of diagnostics.hooks) {
-                ctx.logger?.warn(`[dsh-agent-plugins-market] suite "${diagnostic.suiteId}" hooks: ${diagnostic.reason}`);
-            }
-            for (const error of diagnostics.errors) {
-                ctx.logger?.warn(`[dsh-agent-plugins-market] ${error.surface} reconcile failed: ${error.reason}`);
-            }
+    const scheduler = new ReconcileScheduler(ctx, runtime, {
+        enabledSuites: () => catalog.enabledUserSuites(),
+        publishMcpDiagnostics: diagnostics => {
+            catalog.mcpDiagnostics = diagnostics;
         }
-        catch (error) {
-            ctx.logger?.warn(`[dsh-agent-plugins-market] runtime reconcile failed: ${error instanceof Error ? error.message : String(error)}`);
-            throw error;
+    });
+    /** Reconcile the user command mounts and report each failure once. */
+    const reconcileUserCommands = async () => {
+        const diagnostics = await userCommands.reconcile().catch(() => []);
+        for (const reason of diagnostics) {
+            ctx.logger?.warn(`[dsh-agent-plugins-market] user commands: ${reason}`);
         }
     };
-    // Settings, credential and catalog events can arrive during a slow MCP
-    // connection. Keep one current pass and one fresh follow-up, not a queue
-    // of stale snapshots that all reconnect the same servers.
-    const reconcileMounts = () => {
-        if (disposed)
-            return Promise.resolve();
-        reconcileRequested = true;
-        reconciliation ??= (async () => {
-            try {
-                do {
-                    reconcileRequested = false;
-                    await reconcileOnce();
-                } while (reconcileRequested && !disposed);
-            }
-            finally {
-                reconciliation = undefined;
-            }
-        })();
-        return reconciliation;
-    };
     /**
-     * Coalesce credential updates.
-     *
-     * `runtime.usesCredential(ref)` reflects the last completed pass, so an event
-     * arriving while the first reconcile is still running would be filtered out
-     * and the remount lost. Pending refs are therefore kept until the next pass
-     * observes them, and bursts are collapsed into one reconcile.
+     * How long the change pipeline holds the queue on one stage. A mount that
+     * stops responding — a stdio server that never finishes its handshake, a
+     * browser authorization nobody completed — delays its own surface only; the
+     * stage keeps running while the pipeline moves on to the next change.
      */
-    const pendingCredentialRefs = new Set();
-    let credentialFlush;
-    const flushCredentialUpdates = () => {
-        credentialFlush = undefined;
-        const refs = [...pendingCredentialRefs];
-        pendingCredentialRefs.clear();
-        // Re-read the catalog first: an unknown ref means the snapshot predates
-        // this change, so reconcile anyway to refresh the known reference set.
-        void reconcileMounts().catch(() => { });
-        if (refs.length > 0) {
-            ctx.logger?.info?.(`[dsh-agent-plugins-market] reconciling after credential update: ${refs.join(', ')}`);
+    const CHANGE_STAGE_DEADLINE_MS = 20_000;
+    /** Run one pipeline stage, logging its failure or its overrun instead of holding the pipeline. */
+    const runStage = async (stage, work) => {
+        const running = (async () => await work())();
+        void running.catch(error => {
+            ctx.logger?.warn(`[dsh-agent-plugins-market] ${stage} failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
+        if (!(await settlesWithin(running, CHANGE_STAGE_DEADLINE_MS))) {
+            ctx.logger?.warn(`[dsh-agent-plugins-market] ${stage} is still running after ${CHANGE_STAGE_DEADLINE_MS}ms; the change pipeline continues without waiting for it`);
         }
     };
+    /**
+     * Catalog change pipeline: invalidate the derived skill and command
+     * surfaces, refresh the project mounts, then reconcile every runtime mount.
+     * `CatalogContext` schedules it in the background, so a stage that overruns
+     * costs freshness, never the mutation that asked for it.
+     */
     const onChanged = async () => {
         if (disposed)
             return;
         providerControl?.invalidate();
         userPanelControl?.invalidate();
-        await projectCommands?.refresh();
-        await suitePrompts?.refresh();
-        await Promise.all([projectMcp?.refresh(), projectHooks?.refresh()]);
-        const userCommandDiagnostics = await userCommands.reconcile().catch(() => []);
-        for (const reason of userCommandDiagnostics) {
-            ctx.logger?.warn(`[dsh-agent-plugins-market] user commands: ${reason}`);
-        }
-        await reconcileMounts();
+        await runStage('project commands', () => projectCommands?.refresh());
+        await runStage('suite instructions', () => suitePrompts?.refresh());
+        await runStage('project MCP and hooks', () => Promise.all([projectMcp?.refresh(), projectHooks?.refresh()]));
+        await runStage('user commands', () => reconcileUserCommands());
+        await runStage('runtime mounts', () => scheduler.request());
+    };
+    // Background source updates: off until the settings switch says otherwise.
+    const autoUpdate = new SourceAutoUpdater(ctx, () => catalog.refreshSource());
+    const settings = new MarketSettingsNamespace(ctx, dataRoot, hostLocale, {
+        setScanProjectLayouts: enabled => catalog.setScanProjectLayouts(enabled),
+        refreshMcpMounts: () => {
+            void Promise.all([scheduler.request(), projectMcp?.refresh()]).catch(() => { });
+        },
+        setAutoUpdateSources: enabled => autoUpdate.setEnabled(enabled)
+    });
+    // The credentials store powers the MCP re-authorize action (dropping a grant
+    // record forces the next mount through a fresh browser authorization). Every
+    // port below is read at call time: this plugin's apply may run before the
+    // credentials, tools and settings services provision, and a snapshot taken
+    // here would be permanently undefined even after the service is live.
+    // Read at call time: the tools service provisions after apply() returns.
+    let toolsRegistry = toolsServiceOf(ctx);
+    const ports = {
+        mcpToolSnapshot: () => inspectToolRegistry(toolsRegistry),
+        credentialsStore: {
+            deleteGrantRecord: async (serverName) => {
+                const store = ctx.get?.('credentials');
+                await deleteMcpAuthGrant(store, serverName);
+            }
+        },
+        // Re-authorize must rebuild the live bridge, not just drop the grant: the
+        // registry flags the mount and the following reconcile tears it down and
+        // remounts, so the server's 401 restarts the browser authorization.
+        mcpRemount: (suiteId, serverKey) => runtime.forceMcpRemount(suiteId, serverKey),
+        mcpRemountAll: () => runtime.forceMcpRemountAll(),
+        mcpServerOwner: serverName => runtime.mcpServerOwner(serverName),
+        lspStatusSource: runtime.lsp,
+        mcpBackend: () => settings.backend(),
+        setMcpBackend: backend => settings.setBackend(backend),
+        downloadRegion: () => settings.downloadRegion()
     };
-    // The credential store powers the MCP re-authorize action (dropping a grant
-    // record forces the next mount through a fresh browser authorization).
-    // Resolved lazily at call time: this plugin's apply may run before the
-    // credentials plugin provisions, and a snapshot taken here would be
-    // permanently undefined even after the service is live.
-    const catalog = new Catalog({ userRoot, dataRoot, onChanged, ...(config.git === undefined ? {} : { git: config.git }) });
+    const catalog = new Catalog({ userRoot, dataRoot, agentsRoot, onChanged, ports, ...(config.git === undefined ? {} : { git: config.git }) });
     await catalog.load();
     await catalog.mergeSources(config.sources ?? []);
     const resources = createPanelResources(catalog, panels);
-    // Mirror oauth.ts's `credentialIdFor`: the record is stored under the folded
-    // serverName, so the delete must fold the same way or it misses the record.
-    const credentialIdFor = (serverName) => serverName
-        .toLowerCase()
-        .replace(/[^a-z0-9-]+/g, '-')
-        .replace(/^-+|-+$/g, '') || 'server';
-    catalog.setCredentialsStore({
-        deleteGrantRecord: async (serverName) => {
-            const store = ctx.get?.('credentials');
-            if (store?.deleteRecord === undefined)
-                throw new Error('credentials service is not mounted');
-            await store.deleteRecord(`mcp-auth/${credentialIdFor(serverName)}`);
-        }
-    });
     runtime.setMcpOverridesProvider(async () => catalog.allMcpOverrides(await catalog.enabledUserSuites()));
-    // Re-authorize must rebuild the live bridge, not just drop the grant: the
-    // registry flags the mount and the following reconcile tears it down and
-    // remounts, so the server's 401 restarts the browser authorization.
-    catalog.setMcpRemountHook((suiteId, serverKey) => runtime.forceMcpRemount(suiteId, serverKey), serverName => runtime.mcpServerOwner(serverName));
-    catalog.setLspStatusSource(runtime.lsp);
-    runtime.lsp.setDirectProvider(async () => (await loadLspServers(dataRoot)).servers);
+    runtime.lsp.setDirectProvider(async () => (await loadLspServers(agentsRoot)).servers);
     runtime.lsp.setDisabledProvider(() => loadDisabledLspServers(dataRoot));
-    // The MCP backend choice is a host settings namespace (the registration is
-    // also what makes the plugin-config tab serve our card). The node half owns
-    // it: the provider derives the mount backend from the scope, the writer
-    // flips the switch, and the watcher remounts servers when it flips. The
-    // same single registration also gates the experience-feedback tool —
-    // `settings.register` throws on a duplicate namespace, so there is exactly
-    // one inject block and one `register` call.
-    //
-    // The whole callback is failure-contained on purpose: a throw here is
-    // INVISIBLE in the UI (the inject resolves asynchronously and cordis only
-    // logs), and it silently removes the namespace from settings.describe —
-    // which is exactly what hides the plugin-config card. Every failure mode
-    // lands in the logger with a loud prefix instead.
-    let feedbackDisposer;
-    ctx.inject(['settings'], settingsCtx => {
-        try {
-            ctx.logger?.info?.('[dsh-agent-plugins-market] settings inject resolved — registering namespace');
-            const settings = settingsCtx.settings;
-            const scope = settings.register(MCP_SETTINGS_NAMESPACE, MarketSettingsSchema, {
-                base: { mcpEnhanced: true, downloadRegion: 'auto', feedbackEnabled: true, scanProjectLayouts: true }
-            });
-            ctx.logger?.info?.('[dsh-agent-plugins-market] settings namespace registered — plugin-config card will serve');
-            catalog.setMcpBackendProvider(async () => (scope.get().mcpEnhanced === false ? 'host' : 'builtin'));
-            catalog.setMcpBackendWriter(async (backend) => {
-                await scope.update({ mcpEnhanced: backend !== 'host' });
-            });
-            catalog.setDownloadRegionProvider(async () => narrowDownloadRegion(scope.get().downloadRegion));
-            const syncProjectLayouts = () => {
-                void catalog.setScanProjectLayouts(scope.get().scanProjectLayouts !== false).catch(error => {
-                    ctx.logger?.error?.(`[dsh-agent-plugins-market] project layout reconciliation failed: ${String(error)}`);
-                });
-            };
-            syncProjectLayouts();
-            settingsWatchers.push(scope.watch(syncProjectLayouts));
-            // One-time migration from the earlier data-root settings.json choice.
-            void readMcpBackend(dataRoot).then(backend => {
-                if (backend === 'host')
-                    void scope.update({ mcpEnhanced: false }).catch(() => { });
-            });
-            let previousBackend = scope.get().mcpEnhanced !== false;
-            settingsWatchers.push(scope.watch(() => {
-                const backend = scope.get().mcpEnhanced !== false;
-                if (backend === previousBackend)
-                    return;
-                previousBackend = backend;
-                void Promise.all([reconcileMounts(), projectMcp?.refresh()]).catch(() => { });
-            }));
-            // The experience-feedback model tool: gated by the namespace's
-            // `feedbackEnabled` field (default on); the switch unregisters it. The
-            // tool mount is doubly contained — its failure must never take the
-            // settings namespace (and with it the config card) down with it.
-            const syncFeedbackTool = () => {
-                try {
-                    const state = scope.get();
-                    const wanted = state.feedbackEnabled !== false;
-                    if (wanted && feedbackDisposer === undefined) {
-                        feedbackDisposer = mountFeedbackTool(ctx, dataRoot, (key, params) => hostLocale.t(key, params)) ?? undefined;
-                    }
-                    else if (!wanted && feedbackDisposer !== undefined) {
-                        feedbackDisposer();
-                        feedbackDisposer = undefined;
-                    }
-                }
-                catch (error) {
-                    ctx.logger?.error?.(`[dsh-agent-plugins-market] feedback tool mount failed: ${error instanceof Error ? (error.stack ?? error.message) : String(error)}`);
-                }
-            };
-            syncFeedbackTool();
-            settingsWatchers.push(scope.watch(() => syncFeedbackTool()));
-        }
-        catch (error) {
-            ctx.logger?.error?.(`[dsh-agent-plugins-market] settings namespace registration failed — the plugin-config card will be hidden this boot: ${error instanceof Error ? (error.stack ?? error.message) : String(error)}`);
-        }
-    });
     runtime.setMcpBackendProvider(() => catalog.mcpBackend());
-    const eventHost = ctx;
-    const disposeCredentialUpdates = eventHost.on?.('credentials/reference-updated', ref => {
-        pendingCredentialRefs.add(ref);
-        if (credentialFlush !== undefined)
-            clearTimeout(credentialFlush);
-        credentialFlush = setTimeout(flushCredentialUpdates, 150);
-        credentialFlush.unref?.();
-    }) ?? (() => { });
+    // The namespace must be registered after the catalog exists: the host
+    // resolves the inject callback synchronously when the settings service is
+    // already mounted, and the registration reads back the project-layout switch.
+    settings.mount();
     ctx.inject(['tools'], toolsCtx => {
-        const registry = toolsCtx.tools;
-        catalog.setMcpToolSnapshotProvider(() => inspectToolRegistry(registry));
+        toolsRegistry = toolsCtx.tools;
         // Foreign-namespace guard: a native host MCP client (or another plugin)
         // owning `mcp__<serverName>__` names makes the mount registry skip its
         // own server with a clear diagnostic instead of failing mid-registration.
-        runtime.setMcpToolNamesProvider(() => inspectToolRegistry(registry).map(tool => tool.name));
+        runtime.setMcpToolNamesProvider(() => inspectToolRegistry(toolsRegistry).map(tool => tool.name));
     });
     void Promise.resolve()
         .then(async () => {
-        const userCommandDiagnostics = await userCommands.reconcile().catch(() => []);
-        for (const reason of userCommandDiagnostics) {
-            ctx.logger?.warn(`[dsh-agent-plugins-market] user commands: ${reason}`);
-        }
-        await reconcileMounts();
+        await reconcileUserCommands();
+        await scheduler.request();
     })
         .catch(() => { });
+    // The shell seam resolves lazily: the service may land after this plugin, and
+    // a profile without one keeps dynamic-context placeholders literal.
+    const shellSeam = () => shellSeamOf(ctx);
     ctx.skills.registerProvider(control => {
         providerControl = control;
-        return new SuiteSkillProvider(catalog);
+        return new SuiteSkillProvider(catalog, { dataRoot, shell: shellSeam });
     });
     // User panel skills ride a second provider so a panel
     // edit invalidates only its own catalog contribution.
     ctx.skills.registerProvider(control => {
         userPanelControl = control;
-        return new UserPanelSkillProvider(panels.skills, key => hostLocale.t(key));
+        return new UserPanelSkillProvider(panels.skills);
     });
     ctx.inject(['tools', 'llm', 'subagents', 'agents'], hostCtx => {
         hostCtx.effect(() => mountAgentRoleTool(hostCtx, async (parent) => [
@@ -284,10 +188,10 @@ export async function apply(ctx, config = {}) {
     });
     ctx.inject(['agents'], hostCtx => {
         hostCtx.effect(() => {
-            const mounted = mountProjectCommands(hostCtx, catalog, key => hostLocale.t(key));
+            const mounted = mountProjectCommands(hostCtx, catalog, key => hostLocale.t(key), dataRoot);
             const mcp = mountProjectMcp(hostCtx, catalog, dataRoot);
             const hooks = mountProjectHooks(hostCtx, catalog);
-            const prompts = mountSuiteInstructions(hostCtx, catalog);
+            const prompts = mountSuiteInstructions(hostCtx, catalog, dataRoot);
             projectCommands = mounted;
             projectMcp = mcp;
             projectHooks = hooks;
@@ -310,15 +214,9 @@ export async function apply(ctx, config = {}) {
     });
     ctx.effect(() => () => {
         disposed = true;
-        disposeCredentialUpdates();
-        if (credentialFlush !== undefined)
-            clearTimeout(credentialFlush);
-        credentialFlush = undefined;
-        pendingCredentialRefs.clear();
-        for (const dispose of settingsWatchers.splice(0))
-            dispose();
-        feedbackDisposer?.();
-        feedbackDisposer = undefined;
+        scheduler.dispose();
+        autoUpdate.dispose();
+        settings.dispose();
         userCommands.disposeAll();
         void runtime.dispose();
     }, 'dsh-agent-plugins-market: lifecycle');

package/lib/model/layouts.js

@@ -15,6 +15,10 @@ export const MANIFEST_ALIASES = { kimi: ['kimi.plugin.json'] };
 /** Equivalent plugin-owned path variables; these never resolve as credentials. */
 export const PLUGIN_ROOT_VARIABLES = new Set(['PLUGIN_ROOT', 'CLAUDE_PLUGIN_ROOT', 'CODEX_PLUGIN_ROOT', 'ZCODE_PLUGIN_ROOT', 'QODER_PLUGIN_ROOT']);
 export const PLUGIN_DATA_VARIABLES = new Set(['PLUGIN_DATA', 'CLAUDE_PLUGIN_DATA', 'ZCODE_PLUGIN_DATA', 'QODER_PLUGIN_DATA']);
+/** Equivalent session project-directory variables; only a calling session supplies the directory. */
+export const PROJECT_DIR_VARIABLES = new Set(['CLAUDE_PROJECT_DIR', 'ZCODE_PROJECT_DIR', 'QODER_PROJECT_DIR']);
+/** Claude Code names the directory holding the skill's own file; no dialect alias exists. */
+export const SKILL_DIR_VARIABLE = 'CLAUDE_SKILL_DIR';
 export const PROJECT_LAYOUTS = [
     {
         dirName: '.claude',
@@ -23,7 +27,12 @@ export const PROJECT_LAYOUTS = [
         mcpFiles: ['.mcp.json'],
         hookFiles: ['.claude/settings.json', '.claude/settings.local.json']
     },
-    { dirName: '.agents', label: 'agents', subdirs: ['skills', 'agents', 'commands'] },
+    {
+        dirName: '.agents',
+        label: 'agents',
+        subdirs: ['skills', 'agents', 'commands'],
+        hookFiles: ['.agents/hooks/hooks.json', '.agents/hooks.json']
+    },
     { dirName: '.codex', label: 'Codex', subdirs: ['skills'], mcpFiles: ['.codex/config.toml'], mcpFormat: 'codex' },
     { dirName: '.cursor', label: 'Cursor', subdirs: ['skills', 'agents', 'commands'], mcpFiles: ['.cursor/mcp.json'] },
     { dirName: '.kimi', label: 'Kimi', subdirs: ['skills'] },

package/lib/model/types.js

@@ -7,11 +7,34 @@
  * Codex `.codex-plugin/plugin.json`). Discovery maps every layout onto this
  * internal shape; runtime injection consumes only the internal shape.
  */
-/** Archive URL extensions the archive acquisition path understands. */
-const ARCHIVE_URL_PATTERN = /\.(zip|tgz|tar\.gz|tar)$/i;
+/**
+ * Archive URL suffixes with the payload kind each names, longest suffix first
+ * so `.tar.gz` wins over `.tar`. Source-kind inference, source-id derivation,
+ * and archive extraction all read this one table.
+ */
+export const ARCHIVE_SUFFIXES = [
+    ['.tar.gz', 'targz'],
+    ['.tgz', 'targz'],
+    ['.zip', 'zip'],
+    ['.tar', 'tar']
+];
+/** The archive suffix `url` ends with, or undefined when it names no known payload. */
+function matchArchiveSuffix(url) {
+    const clean = url.trim().toLowerCase();
+    return ARCHIVE_SUFFIXES.find(([suffix]) => clean.endsWith(suffix));
+}
+/** Classify an archive URL by extension; undefined when unsupported. */
+export function archiveFormatOf(url) {
+    return matchArchiveSuffix(url)?.[1];
+}
 /** Whether a URL points at a downloadable archive. */
 export function isArchiveUrl(url) {
-    return ARCHIVE_URL_PATTERN.test(url.trim());
+    return matchArchiveSuffix(url) !== undefined;
+}
+/** Drop a trailing archive suffix (`plugin-0.1.zip` → `plugin-0.1`); other values pass through. */
+export function stripArchiveSuffix(value) {
+    const suffix = matchArchiveSuffix(value)?.[0];
+    return suffix === undefined ? value : value.slice(0, -suffix.length);
 }
 /**
  * Effective acquisition kind of a source: the explicit `kind` wins, the