dsh-agent-plugins-market 0.4.3

package/lib/git.js

@@ -0,0 +1,52 @@
+/**
+ * Git operations for repository sources: clone, pull, head, remove.
+ *
+ * Every operation runs `git` through `execFile` without a shell, so a source
+ * URL or branch can never interpolate into a command string. Failures carry
+ * the stderr tail as the message; the manager surfaces them as source errors.
+ */
+import { execFile } from 'node:child_process';
+import { rm } from 'node:fs/promises';
+import { promisify } from 'node:util';
+const run = promisify(execFile);
+const DEFAULT_TIMEOUT_MS = 120_000;
+/** Clone a source (depth 1, optional branch) into a not-yet-existing directory. */
+export async function gitClone(url, branch, dest, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const args = ['clone', '--depth', '1', ...(branch === undefined ? [] : ['--branch', branch]), '--', url, dest];
+    try {
+        await run('git', args, { timeout: timeoutMs, maxBuffer: 10 * 1024 * 1024 });
+    }
+    catch (error) {
+        throw gitError('clone', error);
+    }
+}
+/** Fast-forward a checked-out source to its configured branch. */
+export async function gitPull(dir, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    try {
+        await run('git', ['-C', dir, 'pull', '--ff-only'], { timeout: timeoutMs, maxBuffer: 10 * 1024 * 1024 });
+    }
+    catch (error) {
+        throw gitError('pull', error);
+    }
+}
+/** Read the checked-out HEAD commit. */
+export async function gitHead(dir, timeoutMs = 30_000) {
+    try {
+        const { stdout } = await run('git', ['-C', dir, 'rev-parse', 'HEAD'], { timeout: timeoutMs });
+        return stdout.trim();
+    }
+    catch (error) {
+        throw gitError('rev-parse', error);
+    }
+}
+/** Remove a source checkout tree entirely. */
+export async function gitRemove(dir) {
+    await rm(dir, { recursive: true, force: true });
+}
+function gitError(operation, error) {
+    if (error instanceof Error && 'stderr' in error && typeof error.stderr === 'string') {
+        const stderr = error.stderr.trim();
+        return new Error(`git ${operation} failed: ${stderr.split('\n').at(-1) ?? stderr}`);
+    }
+    return new Error(`git ${operation} failed: ${error instanceof Error ? error.message : String(error)}`);
+}

package/lib/hooks-mounts.js

@@ -0,0 +1,95 @@
+/**
+ * Claude Code hook compatibility: each enabled suite's `hooks/hooks.json`
+ * mounts one live `dsh-hooks-claude-code` bridge on the harness's canonical
+ * interception points (SessionStart, UserPromptSubmit, PreToolUse,
+ * PostToolUse, Stop, SubagentStart, SubagentStop).
+ *
+ * The bridge is a cordis function plugin (`inject: ['shell']`) whose config
+ * is a single `configPath` plus `pluginRoot` for `${CLAUDE_PLUGIN_ROOT}`
+ * substitution — exactly the shape a suite hook file needs. Mounts reconcile
+ * on every enable/disable/install/uninstall; a missing bridge package, a
+ * broken hook file, or a mount failure is contained per suite.
+ */
+import { stat } from 'node:fs/promises';
+import { join } from 'node:path';
+export class HooksMountRegistry {
+    ctx;
+    live = new Map();
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /** Mount/unmount one bridge per suite to match the enabled suites exactly. */
+    async reconcile(enabledSuites) {
+        const diagnostics = [];
+        const wanted = new Set(enabledSuites.map(suite => suite.id));
+        for (const [suiteId, handle] of [...this.live]) {
+            if (!wanted.has(suiteId)) {
+                await this.unmount(suiteId, handle);
+            }
+        }
+        for (const suite of enabledSuites) {
+            if (this.live.has(suite.id))
+                continue;
+            const reason = await this.mount(suite);
+            if (reason !== undefined)
+                diagnostics.push({ suiteId: suite.id, reason });
+        }
+        return diagnostics;
+    }
+    /** Dispose every live bridge; used at plugin teardown. */
+    async disposeAll() {
+        for (const [suiteId, handle] of [...this.live]) {
+            await this.unmount(suiteId, handle);
+        }
+    }
+    async mount(suite) {
+        const configPath = await hookConfigPath(suite.root);
+        if (configPath === undefined)
+            return undefined;
+        let bridge;
+        try {
+            bridge = await import('@deepseek-ai/dsh-hooks-claude-code');
+        }
+        catch {
+            return 'the @deepseek-ai/dsh-hooks-claude-code package is not installed in this profile';
+        }
+        const mountCtx = this.ctx;
+        if (typeof mountCtx.plugin !== 'function')
+            return 'the host context does not support dynamic plugin mounting';
+        try {
+            const handle = mountCtx.plugin(bridge, {
+                configPath,
+                pluginRoot: suite.root,
+            });
+            await handle.await();
+            this.live.set(suite.id, handle);
+            return undefined;
+        }
+        catch (error) {
+            return `mount failed: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    async unmount(suiteId, handle) {
+        this.live.delete(suiteId);
+        try {
+            await handle.dispose();
+        }
+        catch (error) {
+            this.ctx.logger?.warn(`[dsh-agent-plugins-market] hooks unmount ${suiteId} failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
+/** The first existing CC hook config of a suite root. */
+export async function hookConfigPath(root) {
+    for (const relative of [join('hooks', 'hooks.json'), 'hooks.json']) {
+        const path = join(root, relative);
+        try {
+            if ((await stat(path)).isFile())
+                return path;
+        }
+        catch {
+            // try the next candidate
+        }
+    }
+    return undefined;
+}

package/lib/index.js

@@ -0,0 +1,73 @@
+import { CommandMountRegistry } from './commands-mounts.js';
+import { HooksMountRegistry } from './hooks-mounts.js';
+import { mountSuiteContext } from './context.js';
+import { SuiteManager } from './manager.js';
+import { McpMountRegistry } from './mcp-mounts.js';
+import { resolveDataRoot, resolveUserRoot } from './paths.js';
+import { mountSuiteRoutes } from './routes.js';
+import { SuiteSkillProvider } from './skills-provider.js';
+export const name = 'dsh-agent-plugins-market';
+export const inject = ['skills', 'commands'];
+export function apply(ctx, config = {}) {
+    const userRoot = resolveUserRoot(config.userRoot);
+    const dataRoot = resolveDataRoot(config.dataRoot);
+    let providerControl;
+    const mounts = new McpMountRegistry(ctx, dataRoot);
+    const commandMounts = new CommandMountRegistry(ctx);
+    const hookMounts = new HooksMountRegistry(ctx);
+    const reconcileMounts = () => {
+        void (async () => {
+            try {
+                const diagnostics = await mounts.reconcile(await manager.enabledUserSuites());
+                for (const diagnostic of diagnostics) {
+                    ctx.logger?.warn(`[dsh-agent-plugins-market] suite "${diagnostic.suiteId}" mcp server "${diagnostic.serverKey}": ${diagnostic.reason}`);
+                }
+            }
+            catch (error) {
+                ctx.logger?.warn(`[dsh-agent-plugins-market] mcp reconcile failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            try {
+                const diagnostics = await commandMounts.reconcile(await manager.enabledUserSuites());
+                for (const diagnostic of diagnostics) {
+                    if (diagnostic.reason !== '')
+                        ctx.logger?.warn(`[dsh-agent-plugins-market] suite "${diagnostic.suiteId}" command "${diagnostic.command}": ${diagnostic.reason}`);
+                }
+            }
+            catch (error) {
+                ctx.logger?.warn(`[dsh-agent-plugins-market] command reconcile failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            try {
+                const diagnostics = await hookMounts.reconcile(await manager.enabledUserSuites());
+                for (const diagnostic of diagnostics) {
+                    ctx.logger?.warn(`[dsh-agent-plugins-market] suite "${diagnostic.suiteId}" hooks: ${diagnostic.reason}`);
+                }
+            }
+            catch (error) {
+                ctx.logger?.warn(`[dsh-agent-plugins-market] hooks reconcile failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        })();
+    };
+    const onChanged = () => {
+        providerControl?.invalidate();
+        reconcileMounts();
+    };
+    const manager = new SuiteManager({ userRoot, dataRoot, onChanged });
+    void manager.load().then(async () => {
+        await manager.mergeSources(config.sources ?? []);
+        reconcileMounts();
+    });
+    ctx.skills.registerProvider((control) => {
+        providerControl = control;
+        return new SuiteSkillProvider(manager);
+    });
+    const disposeContext = mountSuiteContext(ctx, manager);
+    ctx.inject(['webServer', 'loader'], (hostCtx) => {
+        hostCtx.effect(() => mountSuiteRoutes(hostCtx, manager), 'dsh-agent-plugins-market: http routes');
+    });
+    ctx.effect(() => () => {
+        void mounts.disposeAll();
+        void hookMounts.disposeAll();
+        commandMounts.disposeAll();
+        disposeContext();
+    }, 'dsh-agent-plugins-market: lifecycle');
+}