@max-null/dsh-plugin-center 0.1.0

package/dist/engine.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Plugin-center engine: the process-local composition of metadata, market,
+ * and update detection. Read-only over the Loader except install/update, which
+ * delegate to pnpm (mirroring `dsh plugin add`). The market catalog is fetched
+ * in batches behind a process-local cache, so listMarket returns what is ready
+ * so far and the client waterfalls until done.
+ */
+import { Service, type Context } from '@deepseek-ai/cordis';
+import { type InstalledPlugin } from './meta.ts';
+import { type MarketPlugin } from './market.ts';
+import { type UpdateDigest } from './update.ts';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        /** The plugin-center engine (provided by this package's host half). */
+        pluginCenter: PluginCenterEngine;
+    }
+}
+/** Which market directory the client wants to browse. */
+export type MarketSource = 'all' | 'awesome' | 'oh-my-dsh';
+/** What's New read-mark result, returned by listMarket so the client waterfalls. */
+export interface MarketSnapshot {
+    plugins: MarketPlugin[];
+    done: boolean;
+}
+export declare class PluginCenterEngine extends Service {
+    static inject: string[];
+    private awesomeCache;
+    private awesomeDone;
+    private awesomeFetching;
+    private ohMyDshCache;
+    private ohMyDshDone;
+    private ohMyDshFetching;
+    private installedNamesCache;
+    private updatesCache;
+    private readonly updatesTtlMs;
+    constructor(ctx: Context);
+    /** Background preload of market + installed metadata; failures fall back to lazy load. */
+    private warmup;
+    /** The profile directory (cordis.yml anchor) — the resolution and install cwd. */
+    private get baseUrl();
+    /** DSH home directory, for the read-mark persistence file. */
+    private get dshHome();
+    private get readVersionsPath();
+    /** Durable read-mark: which plugin version the user has already seen. */
+    readVersions(): Promise<Record<string, string>>;
+    /** Persist the read-mark (best-effort; a quota/IO failure just loses the mark). */
+    markRead(versions: Record<string, string>): Promise<void>;
+    /** Current DSH version, read from the installed @deepseek-ai/dsh package. */
+    dshVersion(): Promise<string>;
+    /** Non-group Loader entries, cross-matched with market categories. */
+    listInstalled(): Promise<InstalledPlugin[]>;
+    /** Start the awesome catalog fetch once, keeping the process-local cache. */
+    private prefetchAwesome;
+    /** Backfill npm latest versions into the awesome cache (best-effort, concurrent). */
+    private fillNpmVersions;
+    /** Single-registry latest version for the market bulk backfill (npmmirror is fast). */
+    private fastNpmVersion;
+    /** Start the Oh-My-DSH fetch once (single PLUGINS.md parse). */
+    private prefetchOhMyDsh;
+    /** Installed plugin names (no file IO) — cached so market polling stays cheap. */
+    private installedNames;
+    /** Market snapshot for one source: what is cached so far, plus whether done. */
+    listMarket(source?: MarketSource): Promise<MarketSnapshot>;
+    /** Detect updates for every installed third-party/local plugin, TTL-cached. */
+    checkUpdates(sinceIso: string): Promise<UpdateDigest[]>;
+    install(spec: string): Promise<boolean>;
+    update(name: string): Promise<boolean>;
+    /** Temporary diagnostics for the empty-update bug; removed once root-caused. */
+    debug(): Promise<{
+        baseUrl: string;
+        installed: {
+            name: string;
+            version: string | null;
+            source: string;
+        }[];
+    }>;
+}

package/dist/engine.js

@@ -0,0 +1,242 @@
+/**
+ * Plugin-center engine: the process-local composition of metadata, market,
+ * and update detection. Read-only over the Loader except install/update, which
+ * delegate to pnpm (mirroring `dsh plugin add`). The market catalog is fetched
+ * in batches behind a process-local cache, so listMarket returns what is ready
+ * so far and the client waterfalls until done.
+ */
+import { Service } from '@deepseek-ai/cordis';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { buildInstalledPlugin, resolvePackage } from "./meta.js";
+import { fetchAwesomePluginsJson, fetchOhMyDshOverrides, fetchOhMyDshPlugins, mapConcurrent, mergePlugins } from "./market.js";
+import { detectUpdate, installPlugin, updatePlugin } from "./update.js";
+/** Runtime mirror of cordis FiberState (a cross-package const enum). */
+const FIBER_PHASE = {
+    0: 'pending',
+    1: 'loading',
+    2: 'active',
+    3: 'failed',
+    4: null,
+    5: 'unloading',
+};
+/** Sources that participate in update detection (official/builtin follow DSH itself). */
+const UPDATABLE = new Set(['installed', 'local']);
+export class PluginCenterEngine extends Service {
+    static inject = ['loader'];
+    awesomeCache = [];
+    awesomeDone = false;
+    awesomeFetching = false;
+    ohMyDshCache = [];
+    ohMyDshDone = false;
+    ohMyDshFetching = false;
+    installedNamesCache = null;
+    updatesCache = null;
+    updatesTtlMs = 5 * 60_000;
+    constructor(ctx) {
+        super(ctx, 'pluginCenter');
+        // Warm caches in the background once the host is up, so opening the panel
+        // hits preloaded data instead of fetching on first paint. The loader is
+        // already settled (injected dependency), so entries() is complete here.
+        void this.warmup();
+    }
+    /** Background preload of market + installed metadata; failures fall back to lazy load. */
+    async warmup() {
+        try {
+            await this.listInstalled();
+        }
+        catch { /* listInstalled is re-run on demand */ }
+        this.prefetchAwesome();
+        this.prefetchOhMyDsh();
+    }
+    /** The profile directory (cordis.yml anchor) — the resolution and install cwd. */
+    get baseUrl() {
+        if (this.ctx.baseUrl === undefined) {
+            throw new Error('plugin-center: ctx.baseUrl is unset — the host needs the profile anchor');
+        }
+        const raw = this.ctx.baseUrl;
+        // ctx.baseUrl is a file:// URL; createRequire and pnpm need a plain path.
+        return raw.startsWith('file://') ? fileURLToPath(raw) : raw;
+    }
+    /** DSH home directory, for the read-mark persistence file. */
+    get dshHome() {
+        const env = process.env.DSH_HOME;
+        if (env !== undefined && env !== '')
+            return env;
+        return dirname(dirname(this.baseUrl)); // baseUrl = …/profiles/<name> → …/
+    }
+    get readVersionsPath() {
+        return join(this.dshHome, 'plugin-center-read-versions.json');
+    }
+    /** Durable read-mark: which plugin version the user has already seen. */
+    async readVersions() {
+        try {
+            return JSON.parse(await readFile(this.readVersionsPath, 'utf8'));
+        }
+        catch {
+            return {};
+        }
+    }
+    /** Persist the read-mark (best-effort; a quota/IO failure just loses the mark). */
+    async markRead(versions) {
+        try {
+            const path = this.readVersionsPath;
+            await mkdir(dirname(path), { recursive: true });
+            await writeFile(path, JSON.stringify(versions), 'utf8');
+        }
+        catch { /* best-effort */ }
+    }
+    /** Current DSH version, read from the installed @deepseek-ai/dsh package. */
+    async dshVersion() {
+        const resolved = await resolvePackage(this.baseUrl, '@deepseek-ai/dsh');
+        return resolved?.pkg.version ?? '0.0.0';
+    }
+    /** Non-group Loader entries, cross-matched with market categories. */
+    async listInstalled() {
+        const views = [];
+        for (const entry of this.ctx.loader.entries()) {
+            if (entry.options.group)
+                continue;
+            views.push({
+                id: entry.id,
+                name: entry.options.name,
+                disabled: entry.disabled,
+                fiberPhase: entry.fiber === undefined ? null : FIBER_PHASE[entry.fiber.state],
+            });
+        }
+        const categoryByName = new Map(mergePlugins([this.awesomeCache, this.ohMyDshCache]).map(m => [m.name, m.categories]));
+        const plugins = await Promise.all(views.map(v => buildInstalledPlugin(this.baseUrl, v)));
+        // Sort local dev first, then third-party installs, then official, then builtin.
+        const SOURCE_ORDER = { local: 0, installed: 1, official: 2, builtin: 3 };
+        return plugins
+            .map(p => ({ ...p, categories: categoryByName.get(p.name) ?? [] }))
+            .sort((a, b) => SOURCE_ORDER[a.source] - SOURCE_ORDER[b.source]);
+    }
+    /** Start the awesome catalog fetch once, keeping the process-local cache. */
+    prefetchAwesome() {
+        if (this.awesomeFetching || this.awesomeDone)
+            return;
+        this.awesomeFetching = true;
+        void (async () => {
+            try {
+                const [plugins, overrides] = await Promise.all([fetchAwesomePluginsJson(), fetchOhMyDshOverrides()]);
+                const merged = mergePlugins([plugins]).map((p) => {
+                    const override = overrides[p.name];
+                    return override?.category !== undefined && override.category !== ''
+                        ? { ...p, categories: [...new Set([...p.categories, override.category])] }
+                        : p;
+                });
+                this.awesomeCache = merged;
+                await this.fillNpmVersions();
+            }
+            catch { /* keep whatever cached so far */ }
+            this.awesomeDone = true;
+            this.awesomeFetching = false;
+        })();
+    }
+    /** Backfill npm latest versions into the awesome cache (best-effort, concurrent). */
+    async fillNpmVersions() {
+        const targets = this.awesomeCache.filter(p => p.npm !== null);
+        if (targets.length === 0)
+            return;
+        const versions = await mapConcurrent(targets.map(p => p.npm), 50, this.fastNpmVersion);
+        const versionByNpm = new Map();
+        targets.forEach((p, i) => {
+            const version = versions[i] ?? null;
+            if (version !== null)
+                versionByNpm.set(p.npm, version);
+        });
+        this.awesomeCache = this.awesomeCache.map(p => p.npm !== null && versionByNpm.has(p.npm) ? { ...p, version: versionByNpm.get(p.npm) } : p);
+    }
+    /** Single-registry latest version for the market bulk backfill (npmmirror is fast). */
+    async fastNpmVersion(name) {
+        try {
+            const res = await fetch(`https://registry.npmmirror.com/${name}/latest`, {
+                signal: AbortSignal.timeout(5000),
+            });
+            if (!res.ok)
+                return null;
+            return (await res.json()).version ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Start the Oh-My-DSH fetch once (single PLUGINS.md parse). */
+    prefetchOhMyDsh() {
+        if (this.ohMyDshFetching || this.ohMyDshDone)
+            return;
+        this.ohMyDshFetching = true;
+        void (async () => {
+            try {
+                this.ohMyDshCache = mergePlugins([await fetchOhMyDshPlugins()]);
+            }
+            catch { /* empty on failure */ }
+            this.ohMyDshDone = true;
+            this.ohMyDshFetching = false;
+        })();
+    }
+    /** Installed plugin names (no file IO) — cached so market polling stays cheap. */
+    async installedNames() {
+        if (this.installedNamesCache !== null)
+            return this.installedNamesCache;
+        const names = new Set();
+        for (const entry of this.ctx.loader.entries()) {
+            if (!entry.options.group)
+                names.add(entry.options.name);
+        }
+        this.installedNamesCache = names;
+        return names;
+    }
+    /** Market snapshot for one source: what is cached so far, plus whether done. */
+    async listMarket(source = 'all') {
+        const installedNames = await this.installedNames();
+        const decorate = (plugins) => plugins.map(p => ({ ...p, installed: installedNames.has(p.name) }));
+        if (source === 'awesome') {
+            this.prefetchAwesome();
+            return { plugins: decorate(this.awesomeCache), done: this.awesomeDone };
+        }
+        if (source === 'oh-my-dsh') {
+            this.prefetchOhMyDsh();
+            return { plugins: decorate(this.ohMyDshCache), done: this.ohMyDshDone };
+        }
+        this.prefetchAwesome();
+        this.prefetchOhMyDsh();
+        return {
+            plugins: decorate(mergePlugins([this.awesomeCache, this.ohMyDshCache])),
+            done: this.awesomeDone && this.ohMyDshDone,
+        };
+    }
+    /** Detect updates for every installed third-party/local plugin, TTL-cached. */
+    async checkUpdates(sinceIso) {
+        const now = Date.now();
+        const hit = this.updatesCache;
+        if (hit !== null && hit.since === sinceIso && now - hit.at < this.updatesTtlMs)
+            return hit.digests;
+        const [installed, localDsh] = await Promise.all([this.listInstalled(), this.dshVersion()]);
+        const candidates = installed.filter(p => UPDATABLE.has(p.source) && p.version !== null);
+        const digests = await Promise.all(candidates.map(p => detectUpdate(p.name, p.version, p.repoUrl, p.compatRange, localDsh, sinceIso)));
+        this.updatesCache = { since: sinceIso, at: now, digests: digests.filter((d) => d !== null) };
+        return this.updatesCache.digests;
+    }
+    async install(spec) {
+        const ok = await installPlugin(spec, this.baseUrl);
+        this.installedNamesCache = null;
+        this.updatesCache = null;
+        return ok;
+    }
+    async update(name) {
+        const ok = await updatePlugin(name, this.baseUrl);
+        this.installedNamesCache = null;
+        this.updatesCache = null;
+        return ok;
+    }
+    /** Temporary diagnostics for the empty-update bug; removed once root-caused. */
+    async debug() {
+        return {
+            baseUrl: this.baseUrl,
+            installed: (await this.listInstalled()).map(p => ({ name: p.name, version: p.version, source: p.source })),
+        };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `dsh-plugin-center` host half: mounts the engine and its loopback RPC.
+ * The browser half (`./client`) is picked up through the package's `dsh.client`
+ * declaration; this half registers the process-local engine + RPC channel.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+export { PluginCenterEngine } from './engine.ts';
+export type { InstalledPlugin, PluginSource } from './meta.ts';
+export type { MarketPlugin } from './market.ts';
+export type { UpdateDigest } from './update.ts';
+export { compareVersions, parseVersion, satisfies } from './semver.ts';
+export declare const name = "dsh-plugin-center";
+/** The engine registers its own `loader` dependency; the gateway follows it. */
+export declare const inject: string[];
+export declare function apply(ctx: Context): Promise<void>;

package/dist/index.js

@@ -0,0 +1,11 @@
+import { PluginCenterEngine } from "./engine.js";
+import { PluginCenterRpc } from "./rpc.js";
+export { PluginCenterEngine } from "./engine.js";
+export { compareVersions, parseVersion, satisfies } from "./semver.js";
+export const name = 'dsh-plugin-center';
+/** The engine registers its own `loader` dependency; the gateway follows it. */
+export const inject = ['loader'];
+export async function apply(ctx) {
+    await ctx.plugin(PluginCenterEngine);
+    await ctx.plugin(PluginCenterRpc);
+}

package/dist/market.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Community market: real-time aggregation of multiple plugin directories.
+ * Fetch is host-side (no browser CSP); merge dedupes by repo name and unions
+ * categories. Sources degrade independently — one failing source never blocks
+ * the rest.
+ */
+/** One plugin as the market surface exposes it. */
+export interface MarketPlugin {
+    name: string;
+    url: string;
+    /** Install spec (`github:owner/repo` or an npm package name), from the source. */
+    spec: string;
+    categories: string[];
+    description: {
+        en: string;
+        zh: string;
+    };
+    stars: number | null;
+    /** npm package name when the plugin is published there, else null. */
+    npm: string | null;
+    /** Latest published version (npm), null until fetched / for non-npm plugins. */
+    version: string | null;
+    installed: boolean;
+}
+/** A per-source plugin record before merging. */
+interface RawPlugin {
+    name: string;
+    url: string;
+    spec: string;
+    categories: string[];
+    description: {
+        en: string;
+        zh: string;
+    };
+    stars: number | null;
+    npm: string | null;
+}
+/** Map a bounded set of fetches concurrently, keeping per-fetch failures as null. */
+export declare function mapConcurrent<T>(items: readonly string[], limit: number, fn: (item: string) => Promise<T>): Promise<(T | null)[]>;
+/**
+ * Fetch the built awesome catalog in one request — it is pre-enriched with
+ * GitHub stars and npm package names, so no per-plugin API calls are needed.
+ */
+export declare function fetchAwesomePluginsJson(): Promise<RawPlugin[]>;
+/** Fetch Oh-My-DSH's curated overrides (min_stars filter + category/note overrides). */
+export declare function fetchOhMyDshOverrides(): Promise<Record<string, {
+    category?: string;
+    note?: string;
+}>>;
+/** Parse Oh-My-DSH's PLUGINS.md (markdown table, sectioned by category). */
+export declare function fetchOhMyDshPlugins(): Promise<RawPlugin[]>;
+/** Merge raw per-source records by repo name: union categories, keep non-empty desc/stars. */
+export declare function mergePlugins(sources: RawPlugin[][]): MarketPlugin[];
+export {};

package/dist/market.js

@@ -0,0 +1,125 @@
+const UA = { 'User-Agent': 'dsh-plugin-center' };
+async function rawText(url) {
+    const res = await fetch(url, { signal: AbortSignal.timeout(20000) });
+    if (!res.ok)
+        throw new Error(`HTTP ${res.status}: ${url}`);
+    return res.text();
+}
+/** Map a bounded set of fetches concurrently, keeping per-fetch failures as null. */
+export async function mapConcurrent(items, limit, fn) {
+    const results = new Array(items.length).fill(null);
+    let next = 0;
+    const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+        while (next < items.length) {
+            const i = next++;
+            try {
+                results[i] = await fn(items[i]);
+            }
+            catch { /* degrade to null */ }
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}
+/**
+ * Fetch the built awesome catalog in one request — it is pre-enriched with
+ * GitHub stars and npm package names, so no per-plugin API calls are needed.
+ */
+export async function fetchAwesomePluginsJson() {
+    const res = await fetch('https://awesome-dsh-plugin.com/plugins.json', {
+        headers: UA,
+        signal: AbortSignal.timeout(30000),
+    });
+    if (!res.ok)
+        throw new Error(`awesome plugins.json: HTTP ${res.status}`);
+    const json = await res.json();
+    return json.plugins.map(p => ({
+        name: `${p.owner}/${p.name}`,
+        url: p.url,
+        spec: p.install.replace(/^.*\badd\s+/, ''),
+        categories: typeof p.category === 'string' && p.category !== '' ? [p.category] : [],
+        description: { en: p.description?.en ?? '', zh: p.description?.zh ?? '' },
+        stars: typeof p.stars === 'number' ? p.stars : null,
+        npm: typeof p.npm === 'string' && p.npm !== '' ? p.npm : null,
+    }));
+}
+/** Fetch Oh-My-DSH's curated overrides (min_stars filter + category/note overrides). */
+export async function fetchOhMyDshOverrides() {
+    try {
+        const res = await fetch('https://raw.githubusercontent.com/like-study1/Oh-My-DSH/main/data/curated.json', {
+            signal: AbortSignal.timeout(20000),
+        });
+        if (!res.ok)
+            return {};
+        const json = await res.json();
+        return json.overrides ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Parse Oh-My-DSH's PLUGINS.md (markdown table, sectioned by category). */
+export async function fetchOhMyDshPlugins() {
+    try {
+        const text = await rawText('https://raw.githubusercontent.com/like-study1/Oh-My-DSH/main/PLUGINS.md');
+        const plugins = [];
+        let category = '';
+        for (const line of text.split('\n')) {
+            const section = /^##\s+(.+?)(?:（\d+）)?\s*$/.exec(line);
+            if (section !== null) {
+                category = section[1].trim();
+                continue;
+            }
+            const cells = line.split('|').map(c => c.trim());
+            if (cells.length < 7)
+                continue;
+            const link = /\[([^\]]+)\]\(([^)]+)\)/.exec(cells[1]);
+            if (link === null)
+                continue;
+            const stars = Number(cells[5]);
+            plugins.push({
+                name: link[1],
+                url: link[2],
+                spec: `github:${link[1]}`,
+                categories: category !== '' ? [category] : [],
+                description: { en: '', zh: cells[6] },
+                stars: Number.isFinite(stars) ? stars : null,
+                npm: null,
+            });
+        }
+        return plugins;
+    }
+    catch {
+        return [];
+    }
+}
+/** Merge raw per-source records by repo name: union categories, keep non-empty desc/stars. */
+export function mergePlugins(sources) {
+    const map = new Map();
+    for (const items of sources) {
+        for (const item of items) {
+            const cur = map.get(item.name) ?? {
+                name: item.name,
+                url: item.url,
+                spec: item.spec,
+                categories: [],
+                description: { en: '', zh: '' },
+                stars: null,
+                npm: null,
+                version: null,
+                installed: false,
+            };
+            cur.categories = [...new Set([...cur.categories, ...item.categories])];
+            if (item.description.en !== '')
+                cur.description.en = item.description.en;
+            if (item.description.zh !== '')
+                cur.description.zh = item.description.zh;
+            if (item.stars !== null)
+                cur.stars = item.stars;
+            if (item.npm !== null)
+                cur.npm = item.npm;
+            map.set(item.name, cur);
+        }
+    }
+    return [...map.values()];
+}

package/dist/meta.d.ts

@@ -0,0 +1,53 @@
+/** Where an installed plugin came from. */
+export type PluginSource = 'official' | 'installed' | 'local' | 'builtin';
+/** One resolved installed plugin, ready for the Remote surface. */
+export interface InstalledPlugin {
+    entryId: string;
+    name: string;
+    displayName: string;
+    version: string | null;
+    description: string | null;
+    source: PluginSource;
+    enabled: boolean;
+    fiberPhase: string | null;
+    compatRange: string | null;
+    repoUrl: string | null;
+    /** Community categories, cross-matched from the market catalog (empty until fetched). */
+    categories: string[];
+}
+/** Minimal package.json view this plugin reads. */
+interface PackageJson {
+    name?: string;
+    version?: string;
+    description?: string;
+    repository?: string | {
+        url?: string;
+    };
+    peerDependencies?: Record<string, string>;
+}
+/** Compact a module specifier into a display name without guessing Loader id shape. */
+export declare function displayName(specifier: string): string;
+/**
+ * Resolve one Loader entry to its package.json. `file://` specs walk upward to
+ * the nearest directory holding a package.json; `cordis:*` builtins have none.
+ * Results are cached per (baseUrl, specifier) — the resolution is a pure read
+ * and never changes within a process, so the file I/O happens only once.
+ * @param baseUrl - profile directory (the cordis.yml anchor, `ctx.baseUrl`).
+ * @param specifier - the Loader entry's module specifier.
+ * @returns the parsed package.json and its directory, or null when unresolvable.
+ */
+export declare function resolvePackage(baseUrl: string, specifier: string): Promise<{
+    pkg: PackageJson;
+    dir: string;
+} | null>;
+/** One Loader entry, the subset this plugin reads. */
+export interface LoaderEntryView {
+    id: string;
+    name: string;
+    disabled: boolean;
+    group?: boolean;
+    fiberPhase: string | null;
+}
+/** Build the Remote-ready metadata for one Loader entry. */
+export declare function buildInstalledPlugin(baseUrl: string, entry: LoaderEntryView): Promise<InstalledPlugin>;
+export {};