dsh-agent-plugins-market 0.4.3 → 0.4.5

package/lib/manager.js

@@ -20,6 +20,10 @@ export class SuiteManager {
     state = EMPTY_STATE;
     mutationQueue = Promise.resolve();
     statePath;
+    /** Cached `git rev-parse HEAD` per source id, so overview reads stay instant; cleared whenever a checkout may have moved. */
+    headCache = new Map();
+    /** Latest MCP mount diagnostics (suiteId -> reasons), fed by the host reconcile. */
+    mcpDiagnostics = [];
     constructor(options) {
         this.options = options;
         this.statePath = join(options.userRoot, STATE_FILE_NAME);
@@ -72,6 +76,7 @@ export class SuiteManager {
             agents: remoteUrl === undefined ? await this.agentPreviews(`${suite.root}/agents`) : [],
             lsp: remoteUrl === undefined ? await this.lspPreviews(suite.root) : [],
             errors: suite.errors,
+            mcpErrors: this.mcpDiagnostics.filter(diagnostic => diagnostic.suiteId === suite.id).map(diagnostic => `${diagnostic.serverKey}: ${diagnostic.reason}`),
         };
     }
     async readPreview(path, capBytes = 64 * 1024) {
@@ -101,6 +106,7 @@ export class SuiteManager {
         const suites = await this.discoverDimension('user', this.options.userRoot);
         const sourceRows = [];
         for (const source of this.state.sources) {
+            const inFlight = this.currentSourceState?.sourceId === source.id ? this.currentSourceState : undefined;
             const checkout = this.sourceCheckoutPath(source);
             let cloned = false;
             let lockCommit;
@@ -110,13 +116,27 @@ export class SuiteManager {
                 if (!cloned)
                     error = `local source directory ${checkout} is missing`;
             }
+            else if (inFlight !== undefined) {
+                // A mutation owns this source right now (clone/pull in progress): report
+                // its snapshot instead of racing git against the transient directory.
+                cloned = inFlight.cloned || await isDirectory(checkout);
+                lockCommit = inFlight.head;
+            }
             else {
-                try {
-                    lockCommit = await gitHead(checkout);
+                const cachedHead = this.headCache.get(source.id);
+                if (cachedHead !== undefined && await isDirectory(checkout)) {
                     cloned = true;
+                    lockCommit = cachedHead;
                 }
-                catch {
-                    // not cloned yet (or a broken checkout); the clone attempt records its own error on refresh
+                else {
+                    try {
+                        lockCommit = await gitHead(checkout);
+                        cloned = true;
+                        this.headCache.set(source.id, lockCommit);
+                    }
+                    catch {
+                        // not cloned yet (or a broken checkout); the clone attempt records its own error on refresh
+                    }
                 }
             }
             const sourceSuites = suites.filter(suite => suite.sourceId === source.id);
@@ -145,6 +165,7 @@ export class SuiteManager {
             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,
@@ -194,15 +215,59 @@ export class SuiteManager {
                     throw new Error(`local source directory ${checkout} is missing`);
             }
             else {
-                await this.ensureClone(source);
+                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.options.onChanged();
             return source;
         });
     }
+    /**
+     * Progress snapshot of the source mutation currently in flight, if any.
+     * While present, `overview()` reports it instead of running git against
+     * the transient checkout directory.
+     */
+    currentSourceState;
+    /**
+     * Begin reporting progress for a source mutation: `step` names the active
+     * phase and `cloned` whether the checkout directory exists yet. The client
+     * polls this through the `progress` route while its add-source modal is
+     * open, and `overview()` merges the snapshot into the source row.
+     */
+    beginSourceState(sourceId, step, cloned) {
+        this.currentSourceState = { sourceId, step, cloned };
+    }
+    /** Advance the in-flight mutation's step (checkout state unchanged). */
+    updateSourceStep(step) {
+        if (this.currentSourceState !== undefined) {
+            this.currentSourceState = { ...this.currentSourceState, step };
+        }
+    }
+    /** Stop reporting progress; `overview()` falls back to on-disk inspection. */
+    endSourceState() {
+        this.currentSourceState = undefined;
+    }
+    /** Progress snapshot for the `progress` route (never throws). */
+    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;
@@ -230,6 +295,7 @@ export class SuiteManager {
                 ...(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) };
@@ -247,6 +313,7 @@ export class SuiteManager {
             };
             await saveState(this.statePath, this.state);
             const source = this.state.sources.find(entry => entry.id === sourceId);
+            this.headCache.delete(sourceId);
             if (source === undefined || source.local !== true) {
                 await gitRemove(sourceCheckoutDir(this.options.userRoot, sourceId));
             }
@@ -265,14 +332,27 @@ export class SuiteManager {
                     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 simply means the next overview re-probes
+                    }
                     continue;
                 }
                 await gitPull(checkout);
+                try {
+                    this.headCache.set(source.id, await gitHead(checkout));
+                }
+                catch {
+                    // a failed head read simply means the next overview re-probes
+                }
             }
             this.options.onChanged();
         });

package/lib/routes.js

@@ -46,6 +46,9 @@ export function mountSuiteRoutes(hostCtx, manager) {
     get(`${API_PREFIX}overview`, async (_request, response) => {
         sendJson(response, 200, await manager.overview());
     });
+    get(`${API_PREFIX}progress`, async (_request, response) => {
+        sendJson(response, 200, manager.sourceProgress());
+    });
     get(`${API_PREFIX}config`, async (_request, response) => {
         sendJson(response, 200, { sources: manager.sources });
     });

package/lib/types/manager.d.ts

@@ -9,6 +9,14 @@ export declare class SuiteManager {
     private state;
     private mutationQueue;
     private readonly statePath;
+    /** Cached `git rev-parse HEAD` per source id, so overview reads stay instant; cleared whenever a checkout may have moved. */
+    private readonly headCache;
+    /** Latest MCP mount diagnostics (suiteId -> reasons), fed by the host reconcile. */
+    mcpDiagnostics: Array<{
+        suiteId: string;
+        serverKey: string;
+        reason: string;
+    }>;
     constructor(options: ManagerOptions);
     /** Load persisted state once at plugin activation. */
     load(): Promise<void>;
@@ -50,6 +58,29 @@ export declare class SuiteManager {
         branch?: string;
         local?: boolean;
     }): Promise<SourceRef>;
+    /**
+     * Progress snapshot of the source mutation currently in flight, if any.
+     * While present, `overview()` reports it instead of running git against
+     * the transient checkout directory.
+     */
+    private currentSourceState;
+    /**
+     * Begin reporting progress for a source mutation: `step` names the active
+     * phase and `cloned` whether the checkout directory exists yet. The client
+     * polls this through the `progress` route while its add-source modal is
+     * open, and `overview()` merges the snapshot into the source row.
+     */
+    beginSourceState(sourceId: string, step: string, cloned: boolean): void;
+    /** Advance the in-flight mutation's step (checkout state unchanged). */
+    updateSourceStep(step: string): void;
+    /** Stop reporting progress; `overview()` falls back to on-disk inspection. */
+    endSourceState(): void;
+    /** Progress snapshot for the `progress` route (never throws). */
+    sourceProgress(): {
+        active: boolean;
+        sourceId: string;
+        step: string;
+    };
     private uniqueSourceId;
     /**
      * Update one source's url / branch / local flag. A git source whose URL

package/lib/types/types.d.ts

@@ -137,6 +137,8 @@ export interface SuiteOverviewCard {
     dimension: SuiteDimension;
     layout: SuiteLayoutKind;
     errors: string[];
+    /** Live MCP mount failures for this suite (reason per failed server). */
+    mcpErrors: string[];
 }
 export interface SourceOverview {
     id: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-agent-plugins-market",
-  "description": "Bring the Claude Code / Codex / Cursor plugin-marketplace ecosystem into DeepSeek Harness (DSH): install & inject agent plugins — skills, MCP servers, hooks, slash commands — from git marketplace repos (agent-plugins.org v1.0.0, .claude-plugin, .codex-plugin, .cursor-plugin, .kimi-plugin), with a Web GUI market page.",
-  "version": "0.4.3",
+  "description": "The standard way to install Claude Code / Codex / Cursor / Kimi plugin marketplace suites in DeepSeek Harness (DSH) — zero conversion, zero file copying. Skills, MCP servers, hooks and slash commands are injected into your dsh sessions at runtime.",
+  "version": "0.4.5",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -56,11 +56,18 @@
     "harness",
     "dsh",
     "dsh-plugin",
+    "dsh-plugins",
+    "dsh-marketplace",
+    "dsh-plugin-marketplace",
+    "deepseek-plugin",
+    "deepseek-plugins",
     "agent-plugins",
     "agent-plugin",
     "plugin-marketplace",
     "marketplace",
     "claude-code",
+    "claude-code-plugins",
+    "claude-code-plugin-marketplace",
     "claude",
     "codex",
     "cursor",