@jackwener/opencli 1.4.0 → 1.5.0

package/dist/plugin.js

@@ -2,7 +2,8 @@
  * Plugin management: install, uninstall, and list plugins.
  *
  * Plugins live in ~/.opencli/plugins/<name>/.
- * Install source format: "github:user/repo"
+ * Monorepo clones live in ~/.opencli/monorepos/<repo-name>/.
+ * Install source format: "github:user/repo" or "github:user/repo/subplugin"
  */
 import * as fs from 'node:fs';
 import * as os from 'node:os';
@@ -12,6 +13,7 @@ import { fileURLToPath } from 'node:url';
 import { PLUGINS_DIR } from './discovery.js';
 import { getErrorMessage } from './errors.js';
 import { log } from './logger.js';
+import { readPluginManifest, isMonorepo, getEnabledPlugins, checkCompatibility, } from './plugin-manifest.js';
 const isWindows = process.platform === 'win32';
 /** Get home directory, respecting HOME environment variable for test isolation. */
 function getHomeDir() {
@@ -21,8 +23,13 @@ function getHomeDir() {
 export function getLockFilePath() {
     return path.join(getHomeDir(), '.opencli', 'plugins.lock.json');
 }
+/** Monorepo clones directory: ~/.opencli/monorepos/ */
+export function getMonoreposDir() {
+    return path.join(getHomeDir(), '.opencli', 'monorepos');
+}
 // Legacy const for backward compatibility (computed at load time)
 export const LOCK_FILE = path.join(os.homedir(), '.opencli', 'plugins.lock.json');
+export const MONOREPOS_DIR = path.join(os.homedir(), '.opencli', 'monorepos');
 // ── Lock file helpers ───────────────────────────────────────────────────────
 export function readLockFile() {
     try {
@@ -87,34 +94,53 @@ export function validatePluginStructure(pluginDir) {
     }
     return { valid: errors.length === 0, errors };
 }
-/**
- * Shared post-install lifecycle: npm install → host symlink → TS transpile.
- * Called by both installPlugin() and updatePlugin().
- */
-function postInstallLifecycle(pluginDir) {
-    const pkgJsonPath = path.join(pluginDir, 'package.json');
+function installDependencies(dir) {
+    const pkgJsonPath = path.join(dir, 'package.json');
     if (!fs.existsSync(pkgJsonPath))
         return;
     try {
         execFileSync('npm', ['install', '--omit=dev'], {
-            cwd: pluginDir,
+            cwd: dir,
             encoding: 'utf-8',
             stdio: ['pipe', 'pipe', 'pipe'],
             ...(isWindows && { shell: true }),
         });
     }
     catch (err) {
-        console.error(`[plugin] npm install failed in ${pluginDir}: ${err instanceof Error ? err.message : err}`);
+        throw new Error(`npm install failed in ${dir}: ${getErrorMessage(err)}`);
     }
+}
+function finalizePluginRuntime(pluginDir) {
     // Symlink host opencli so TS plugins resolve '@jackwener/opencli/registry'
     // against the running host, not a stale npm-published version.
     linkHostOpencli(pluginDir);
     // Transpile .ts → .js via esbuild (production node can't load .ts directly).
     transpilePluginTs(pluginDir);
 }
+/**
+ * Shared post-install lifecycle for standalone plugins.
+ */
+function postInstallLifecycle(pluginDir) {
+    installDependencies(pluginDir);
+    finalizePluginRuntime(pluginDir);
+}
+/**
+ * Monorepo lifecycle: install shared deps once at repo root, then finalize each sub-plugin.
+ */
+function postInstallMonorepoLifecycle(repoDir, pluginDirs) {
+    installDependencies(repoDir);
+    for (const pluginDir of pluginDirs) {
+        finalizePluginRuntime(pluginDir);
+    }
+}
 /**
  * Install a plugin from a source.
- * Currently supports "github:user/repo" format (git clone wrapper).
+ * Supports:
+ *   "github:user/repo"            — single plugin or full monorepo
+ *   "github:user/repo/subplugin"  — specific sub-plugin from a monorepo
+ *   "https://github.com/user/repo"
+ *
+ * Returns the installed plugin name(s).
  */
 export function installPlugin(source) {
     const parsed = parseSource(source);
@@ -122,17 +148,14 @@ export function installPlugin(source) {
         throw new Error(`Invalid plugin source: "${source}"\n` +
             `Supported formats:\n` +
             `  github:user/repo\n` +
+            `  github:user/repo/subplugin\n` +
             `  https://github.com/user/repo`);
     }
-    const { cloneUrl, name } = parsed;
-    const targetDir = path.join(PLUGINS_DIR, name);
-    if (fs.existsSync(targetDir)) {
-        throw new Error(`Plugin "${name}" is already installed at ${targetDir}`);
-    }
-    // Ensure plugins directory exists
-    fs.mkdirSync(PLUGINS_DIR, { recursive: true });
+    const { cloneUrl, name: repoName, subPlugin } = parsed;
+    // Clone to a temporary location first so we can inspect the manifest
+    const tmpCloneDir = path.join(os.tmpdir(), `opencli-clone-${Date.now()}`);
     try {
-        execFileSync('git', ['clone', '--depth', '1', cloneUrl, targetDir], {
+        execFileSync('git', ['clone', '--depth', '1', cloneUrl, tmpCloneDir], {
             encoding: 'utf-8',
             stdio: ['pipe', 'pipe', 'pipe'],
         });
@@ -140,48 +163,228 @@ export function installPlugin(source) {
     catch (err) {
         throw new Error(`Failed to clone plugin: ${getErrorMessage(err)}`);
     }
-    const validation = validatePluginStructure(targetDir);
+    try {
+        const manifest = readPluginManifest(tmpCloneDir);
+        // Check top-level compatibility
+        if (manifest?.opencli && !checkCompatibility(manifest.opencli)) {
+            throw new Error(`Plugin requires opencli ${manifest.opencli}, but current version is incompatible.`);
+        }
+        if (manifest && isMonorepo(manifest)) {
+            return installMonorepo(tmpCloneDir, cloneUrl, repoName, manifest, subPlugin);
+        }
+        // Single plugin mode
+        return installSinglePlugin(tmpCloneDir, cloneUrl, repoName, manifest);
+    }
+    finally {
+        // Clean up temp clone (may already have been moved)
+        try {
+            fs.rmSync(tmpCloneDir, { recursive: true, force: true });
+        }
+        catch { }
+    }
+}
+/** Install a single (non-monorepo) plugin. */
+function installSinglePlugin(cloneDir, cloneUrl, name, manifest) {
+    const pluginName = manifest?.name ?? name;
+    const targetDir = path.join(PLUGINS_DIR, pluginName);
+    if (fs.existsSync(targetDir)) {
+        throw new Error(`Plugin "${pluginName}" is already installed at ${targetDir}`);
+    }
+    const validation = validatePluginStructure(cloneDir);
     if (!validation.valid) {
-        // If validation fails, clean up the cloned directory and abort
-        fs.rmSync(targetDir, { recursive: true, force: true });
         throw new Error(`Invalid plugin structure:\n- ${validation.errors.join('\n- ')}`);
     }
+    fs.mkdirSync(PLUGINS_DIR, { recursive: true });
+    fs.renameSync(cloneDir, targetDir);
     postInstallLifecycle(targetDir);
     const commitHash = getCommitHash(targetDir);
     if (commitHash) {
         const lock = readLockFile();
-        lock[name] = {
+        lock[pluginName] = {
             source: cloneUrl,
             commitHash,
             installedAt: new Date().toISOString(),
         };
         writeLockFile(lock);
     }
-    return name;
+    return pluginName;
+}
+/** Install sub-plugins from a monorepo. */
+function installMonorepo(cloneDir, cloneUrl, repoName, manifest, subPlugin) {
+    const monoreposDir = getMonoreposDir();
+    const repoDir = path.join(monoreposDir, repoName);
+    // Move clone to permanent monorepos location (if not already there)
+    if (!fs.existsSync(repoDir)) {
+        fs.mkdirSync(monoreposDir, { recursive: true });
+        fs.renameSync(cloneDir, repoDir);
+    }
+    let pluginsToInstall = getEnabledPlugins(manifest);
+    // If a specific sub-plugin was requested, filter to just that one
+    if (subPlugin) {
+        pluginsToInstall = pluginsToInstall.filter((p) => p.name === subPlugin);
+        if (pluginsToInstall.length === 0) {
+            // Check if it exists but is disabled
+            const disabled = manifest.plugins?.[subPlugin];
+            if (disabled) {
+                throw new Error(`Sub-plugin "${subPlugin}" is disabled in the manifest.`);
+            }
+            throw new Error(`Sub-plugin "${subPlugin}" not found in monorepo. Available: ${Object.keys(manifest.plugins ?? {}).join(', ')}`);
+        }
+    }
+    const installedNames = [];
+    const lock = readLockFile();
+    const commitHash = getCommitHash(repoDir);
+    const eligiblePlugins = [];
+    fs.mkdirSync(PLUGINS_DIR, { recursive: true });
+    for (const { name, entry } of pluginsToInstall) {
+        // Check sub-plugin level compatibility (overrides top-level)
+        if (entry.opencli && !checkCompatibility(entry.opencli)) {
+            log.warn(`Skipping "${name}": requires opencli ${entry.opencli}`);
+            continue;
+        }
+        const subDir = path.join(repoDir, entry.path);
+        if (!fs.existsSync(subDir)) {
+            log.warn(`Skipping "${name}": path "${entry.path}" not found in repo.`);
+            continue;
+        }
+        const validation = validatePluginStructure(subDir);
+        if (!validation.valid) {
+            log.warn(`Skipping "${name}": invalid structure — ${validation.errors.join(', ')}`);
+            continue;
+        }
+        const linkPath = path.join(PLUGINS_DIR, name);
+        if (fs.existsSync(linkPath)) {
+            log.warn(`Skipping "${name}": already installed at ${linkPath}`);
+            continue;
+        }
+        eligiblePlugins.push({ name, entry, subDir });
+    }
+    if (eligiblePlugins.length > 0) {
+        postInstallMonorepoLifecycle(repoDir, eligiblePlugins.map((p) => p.subDir));
+    }
+    for (const { name, entry, subDir } of eligiblePlugins) {
+        const linkPath = path.join(PLUGINS_DIR, name);
+        // Create symlink (junction on Windows)
+        const linkType = isWindows ? 'junction' : 'dir';
+        fs.symlinkSync(subDir, linkPath, linkType);
+        if (commitHash) {
+            lock[name] = {
+                source: cloneUrl,
+                commitHash,
+                installedAt: new Date().toISOString(),
+                monorepo: { name: repoName, subPath: entry.path },
+            };
+        }
+        installedNames.push(name);
+    }
+    writeLockFile(lock);
+    return installedNames;
 }
 /**
  * Uninstall a plugin by name.
+ * For monorepo sub-plugins: removes symlink and cleans up the monorepo
+ * directory when no more sub-plugins reference it.
  */
 export function uninstallPlugin(name) {
     const targetDir = path.join(PLUGINS_DIR, name);
     if (!fs.existsSync(targetDir)) {
         throw new Error(`Plugin "${name}" is not installed.`);
     }
-    fs.rmSync(targetDir, { recursive: true, force: true });
     const lock = readLockFile();
-    if (lock[name]) {
+    const lockEntry = lock[name];
+    // Check if this is a symlink (monorepo sub-plugin)
+    const isSymlink = isSymlinkSync(targetDir);
+    if (isSymlink) {
+        // Remove symlink only (not the actual directory)
+        fs.unlinkSync(targetDir);
+    }
+    else {
+        fs.rmSync(targetDir, { recursive: true, force: true });
+    }
+    // Clean up monorepo directory if no more sub-plugins reference it
+    if (lockEntry?.monorepo) {
+        delete lock[name];
+        const monoName = lockEntry.monorepo.name;
+        const stillReferenced = Object.values(lock).some((entry) => entry.monorepo?.name === monoName);
+        if (!stillReferenced) {
+            const monoDir = path.join(getMonoreposDir(), monoName);
+            try {
+                fs.rmSync(monoDir, { recursive: true, force: true });
+            }
+            catch { }
+        }
+    }
+    else if (lock[name]) {
         delete lock[name];
-        writeLockFile(lock);
+    }
+    writeLockFile(lock);
+}
+/** Synchronous check if a path is a symlink. */
+function isSymlinkSync(p) {
+    try {
+        return fs.lstatSync(p).isSymbolicLink();
+    }
+    catch {
+        return false;
     }
 }
 /**
  * Update a plugin by name (git pull + re-install lifecycle).
+ * For monorepo sub-plugins: pulls the monorepo root and re-runs lifecycle
+ * for all sub-plugins from the same monorepo.
  */
 export function updatePlugin(name) {
     const targetDir = path.join(PLUGINS_DIR, name);
     if (!fs.existsSync(targetDir)) {
         throw new Error(`Plugin "${name}" is not installed.`);
     }
+    const lock = readLockFile();
+    const lockEntry = lock[name];
+    if (lockEntry?.monorepo) {
+        // Monorepo update: pull the repo root
+        const monoDir = path.join(getMonoreposDir(), lockEntry.monorepo.name);
+        try {
+            execFileSync('git', ['pull', '--ff-only'], {
+                cwd: monoDir,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+        }
+        catch (err) {
+            throw new Error(`Failed to update monorepo: ${getErrorMessage(err)}`);
+        }
+        // Re-run lifecycle for ALL sub-plugins from this monorepo
+        const monoName = lockEntry.monorepo.name;
+        const commitHash = getCommitHash(monoDir);
+        const pluginDirs = [];
+        for (const [pluginName, entry] of Object.entries(lock)) {
+            if (entry.monorepo?.name !== monoName)
+                continue;
+            const subDir = path.join(monoDir, entry.monorepo.subPath);
+            const validation = validatePluginStructure(subDir);
+            if (!validation.valid) {
+                log.warn(`Plugin "${pluginName}" structure invalid after update:\n- ${validation.errors.join('\n- ')}`);
+            }
+            pluginDirs.push(subDir);
+        }
+        if (pluginDirs.length > 0) {
+            postInstallMonorepoLifecycle(monoDir, pluginDirs);
+        }
+        for (const [pluginName, entry] of Object.entries(lock)) {
+            if (entry.monorepo?.name !== monoName)
+                continue;
+            if (commitHash) {
+                lock[pluginName] = {
+                    ...entry,
+                    commitHash,
+                    updatedAt: new Date().toISOString(),
+                };
+            }
+        }
+        writeLockFile(lock);
+        return;
+    }
+    // Standard single-plugin update
     try {
         execFileSync('git', ['pull', '--ff-only'], {
             cwd: targetDir,
@@ -199,7 +402,6 @@ export function updatePlugin(name) {
     postInstallLifecycle(targetDir);
     const commitHash = getCommitHash(targetDir);
     if (commitHash) {
-        const lock = readLockFile();
         const existing = lock[name];
         lock[name] = {
             source: existing?.source ?? getPluginSource(targetDir) ?? '',
@@ -231,6 +433,7 @@ export function updateAllPlugins() {
 }
 /**
  * List all installed plugins.
+ * Reads opencli-plugin.json for description/version when available.
  */
 export function listPlugins() {
     if (!fs.existsSync(PLUGINS_DIR))
@@ -239,19 +442,39 @@ export function listPlugins() {
     const lock = readLockFile();
     const plugins = [];
     for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
+        // Accept both real directories and symlinks (monorepo sub-plugins)
         const pluginDir = path.join(PLUGINS_DIR, entry.name);
+        const isDir = entry.isDirectory() || isSymlinkSync(pluginDir);
+        if (!isDir)
+            continue;
         const commands = scanPluginCommands(pluginDir);
-        const source = getPluginSource(pluginDir);
         const lockEntry = lock[entry.name];
+        // Try to read manifest for metadata
+        const manifest = readPluginManifest(pluginDir);
+        // For monorepo sub-plugins, also check the monorepo root manifest
+        let description = manifest?.description;
+        let version = manifest?.version;
+        if (lockEntry?.monorepo && !description) {
+            const monoDir = path.join(getMonoreposDir(), lockEntry.monorepo.name);
+            const monoManifest = readPluginManifest(monoDir);
+            const subEntry = monoManifest?.plugins?.[entry.name];
+            if (subEntry) {
+                description = description ?? subEntry.description;
+                version = version ?? subEntry.version;
+            }
+        }
+        const source = lockEntry?.monorepo
+            ? lockEntry.source
+            : getPluginSource(pluginDir);
         plugins.push({
             name: entry.name,
             path: pluginDir,
             commands,
             source,
-            version: lockEntry?.commitHash?.slice(0, 7),
+            version: version ?? lockEntry?.commitHash?.slice(0, 7),
             installedAt: lockEntry?.installedAt,
+            monorepoName: lockEntry?.monorepo?.name,
+            description,
         });
     }
     return plugins;
@@ -284,8 +507,19 @@ function getPluginSource(dir) {
         return undefined;
     }
 }
-/** Parse a plugin source string into clone URL and name */
+/** Parse a plugin source string into clone URL, repo name, and optional sub-plugin. */
 function parseSource(source) {
+    // github:user/repo/subplugin  (monorepo specific sub-plugin)
+    const githubSubMatch = source.match(/^github:([\w.-]+)\/([\w.-]+)\/([\w.-]+)$/);
+    if (githubSubMatch) {
+        const [, user, repo, sub] = githubSubMatch;
+        const name = repo.replace(/^opencli-plugin-/, '');
+        return {
+            cloneUrl: `https://github.com/${user}/${repo}.git`,
+            name,
+            subPlugin: sub,
+        };
+    }
     // github:user/repo
     const githubMatch = source.match(/^github:([\w.-]+)\/([\w.-]+)$/);
     if (githubMatch) {
@@ -432,4 +666,4 @@ function transpilePluginTs(pluginDir) {
         // Non-fatal: skip transpilation if anything goes wrong
     }
 }
-export { resolveEsbuildBin as _resolveEsbuildBin, getCommitHash as _getCommitHash, parseSource as _parseSource, readLockFile as _readLockFile, updateAllPlugins as _updateAllPlugins, validatePluginStructure as _validatePluginStructure, writeLockFile as _writeLockFile, };
+export { resolveEsbuildBin as _resolveEsbuildBin, getCommitHash as _getCommitHash, installDependencies as _installDependencies, parseSource as _parseSource, postInstallMonorepoLifecycle as _postInstallMonorepoLifecycle, readLockFile as _readLockFile, updateAllPlugins as _updateAllPlugins, validatePluginStructure as _validatePluginStructure, writeLockFile as _writeLockFile, isSymlinkSync as _isSymlinkSync, getMonoreposDir as _getMonoreposDir, };

package/dist/plugin.test.js

@@ -7,7 +7,11 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import { PLUGINS_DIR } from './discovery.js';
 import * as pluginModule from './plugin.js';
-const { LOCK_FILE, _getCommitHash, listPlugins, _readLockFile, _resolveEsbuildBin, uninstallPlugin, updatePlugin, _parseSource, _updateAllPlugins, _validatePluginStructure, _writeLockFile, } = pluginModule;
+const { mockExecFileSync, mockExecSync } = vi.hoisted(() => ({
+    mockExecFileSync: vi.fn(),
+    mockExecSync: vi.fn(),
+}));
+const { LOCK_FILE, _getCommitHash, _installDependencies, _postInstallMonorepoLifecycle, listPlugins, _readLockFile, _resolveEsbuildBin, uninstallPlugin, updatePlugin, _parseSource, _updateAllPlugins, _validatePluginStructure, _writeLockFile, _isSymlinkSync, _getMonoreposDir, } = pluginModule;
 describe('parseSource', () => {
     it('parses github:user/repo format', () => {
         const result = _parseSource('github:ByteYue/opencli-plugin-github-trending');
@@ -239,7 +243,7 @@ describe('updatePlugin', () => {
 });
 vi.mock('node:child_process', () => {
     return {
-        execFileSync: vi.fn((_cmd, args, opts) => {
+        execFileSync: mockExecFileSync.mockImplementation((_cmd, args, opts) => {
             if (Array.isArray(args) && args[0] === 'rev-parse' && args[1] === 'HEAD') {
                 if (opts?.cwd === os.tmpdir()) {
                     throw new Error('not a git repository');
@@ -251,9 +255,50 @@ vi.mock('node:child_process', () => {
             }
             return '';
         }),
-        execSync: vi.fn(() => ''),
+        execSync: mockExecSync.mockImplementation(() => ''),
     };
 });
+describe('installDependencies', () => {
+    beforeEach(() => {
+        mockExecFileSync.mockClear();
+        mockExecSync.mockClear();
+    });
+    it('throws when npm install fails', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-plugin-b-'));
+        const failingDir = path.join(tmpDir, 'plugin-b');
+        fs.mkdirSync(failingDir, { recursive: true });
+        fs.writeFileSync(path.join(failingDir, 'package.json'), JSON.stringify({ name: 'plugin-b' }));
+        expect(() => _installDependencies(failingDir)).toThrow('npm install failed');
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+});
+describe('postInstallMonorepoLifecycle', () => {
+    let repoDir;
+    let subDir;
+    beforeEach(() => {
+        mockExecFileSync.mockClear();
+        mockExecSync.mockClear();
+        repoDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-monorepo-'));
+        subDir = path.join(repoDir, 'packages', 'alpha');
+        fs.mkdirSync(subDir, { recursive: true });
+        fs.writeFileSync(path.join(repoDir, 'package.json'), JSON.stringify({
+            name: 'opencli-plugins',
+            private: true,
+            workspaces: ['packages/*'],
+        }));
+        fs.writeFileSync(path.join(subDir, 'hello.yaml'), 'site: test\nname: hello\n');
+    });
+    afterEach(() => {
+        fs.rmSync(repoDir, { recursive: true, force: true });
+    });
+    it('installs dependencies once at the monorepo root, not in each sub-plugin', () => {
+        _postInstallMonorepoLifecycle(repoDir, [subDir]);
+        const npmCalls = mockExecFileSync.mock.calls.filter(([cmd, args]) => cmd === 'npm' && Array.isArray(args) && args[0] === 'install');
+        expect(npmCalls).toHaveLength(1);
+        expect(npmCalls[0][2]).toMatchObject({ cwd: repoDir });
+        expect(npmCalls.some(([, , opts]) => opts?.cwd === subDir)).toBe(false);
+    });
+});
 describe('updateAllPlugins', () => {
     const testDirA = path.join(PLUGINS_DIR, 'plugin-a');
     const testDirB = path.join(PLUGINS_DIR, 'plugin-b');
@@ -295,3 +340,175 @@ describe('updateAllPlugins', () => {
         expect(resC.success).toBe(true);
     });
 });
+// ── Monorepo-specific tests ─────────────────────────────────────────────────
+describe('parseSource with monorepo subplugin', () => {
+    it('parses github:user/repo/subplugin format', () => {
+        const result = _parseSource('github:ByteYue/opencli-plugins/polymarket');
+        expect(result).toEqual({
+            cloneUrl: 'https://github.com/ByteYue/opencli-plugins.git',
+            name: 'opencli-plugins',
+            subPlugin: 'polymarket',
+        });
+    });
+    it('strips opencli-plugin- prefix from repo name in subplugin format', () => {
+        const result = _parseSource('github:user/opencli-plugin-collection/defi');
+        expect(result.name).toBe('collection');
+        expect(result.subPlugin).toBe('defi');
+    });
+    it('still parses github:user/repo without subplugin', () => {
+        const result = _parseSource('github:user/my-repo');
+        expect(result).toEqual({
+            cloneUrl: 'https://github.com/user/my-repo.git',
+            name: 'my-repo',
+        });
+        expect(result.subPlugin).toBeUndefined();
+    });
+});
+describe('isSymlinkSync', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-symlink-test-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('returns false for a regular directory', () => {
+        const dir = path.join(tmpDir, 'regular');
+        fs.mkdirSync(dir);
+        expect(_isSymlinkSync(dir)).toBe(false);
+    });
+    it('returns true for a symlink', () => {
+        const target = path.join(tmpDir, 'target');
+        const link = path.join(tmpDir, 'link');
+        fs.mkdirSync(target);
+        fs.symlinkSync(target, link, 'dir');
+        expect(_isSymlinkSync(link)).toBe(true);
+    });
+    it('returns false for non-existent path', () => {
+        expect(_isSymlinkSync(path.join(tmpDir, 'nope'))).toBe(false);
+    });
+});
+describe('monorepo uninstall with symlink', () => {
+    let tmpDir;
+    let pluginDir;
+    let monoDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-mono-uninstall-'));
+        // We need to use the real PLUGINS_DIR for uninstallPlugin() to work
+        pluginDir = path.join(PLUGINS_DIR, '__test-mono-sub__');
+        monoDir = path.join(_getMonoreposDir(), '__test-mono__');
+        // Set up monorepo structure
+        const subDir = path.join(monoDir, 'packages', 'sub');
+        fs.mkdirSync(subDir, { recursive: true });
+        fs.writeFileSync(path.join(subDir, 'cmd.yaml'), 'site: test');
+        // Create symlink in plugins dir
+        fs.mkdirSync(PLUGINS_DIR, { recursive: true });
+        fs.symlinkSync(subDir, pluginDir, 'dir');
+        // Set up lock file with monorepo entry
+        const lock = _readLockFile();
+        lock['__test-mono-sub__'] = {
+            source: 'https://github.com/user/test.git',
+            commitHash: 'abc123',
+            installedAt: '2025-01-01T00:00:00.000Z',
+            monorepo: { name: '__test-mono__', subPath: 'packages/sub' },
+        };
+        _writeLockFile(lock);
+    });
+    afterEach(() => {
+        try {
+            fs.unlinkSync(pluginDir);
+        }
+        catch { }
+        try {
+            fs.rmSync(pluginDir, { recursive: true, force: true });
+        }
+        catch { }
+        try {
+            fs.rmSync(monoDir, { recursive: true, force: true });
+        }
+        catch { }
+        // Clean up lock entry
+        const lock = _readLockFile();
+        delete lock['__test-mono-sub__'];
+        _writeLockFile(lock);
+    });
+    it('removes symlink but keeps monorepo if other sub-plugins reference it', () => {
+        // Add another sub-plugin referencing the same monorepo
+        const lock = _readLockFile();
+        lock['__test-mono-other__'] = {
+            source: 'https://github.com/user/test.git',
+            commitHash: 'abc123',
+            installedAt: '2025-01-01T00:00:00.000Z',
+            monorepo: { name: '__test-mono__', subPath: 'packages/other' },
+        };
+        _writeLockFile(lock);
+        uninstallPlugin('__test-mono-sub__');
+        // Symlink removed
+        expect(fs.existsSync(pluginDir)).toBe(false);
+        // Monorepo dir still exists (other sub-plugin references it)
+        expect(fs.existsSync(monoDir)).toBe(true);
+        // Lock entry removed
+        expect(_readLockFile()['__test-mono-sub__']).toBeUndefined();
+        // Other lock entry still present
+        expect(_readLockFile()['__test-mono-other__']).toBeDefined();
+        // Clean up the other entry
+        const finalLock = _readLockFile();
+        delete finalLock['__test-mono-other__'];
+        _writeLockFile(finalLock);
+    });
+    it('removes symlink AND monorepo dir when last sub-plugin is uninstalled', () => {
+        uninstallPlugin('__test-mono-sub__');
+        // Symlink removed
+        expect(fs.existsSync(pluginDir)).toBe(false);
+        // Monorepo dir also removed (no more references)
+        expect(fs.existsSync(monoDir)).toBe(false);
+        // Lock entry removed
+        expect(_readLockFile()['__test-mono-sub__']).toBeUndefined();
+    });
+});
+describe('listPlugins with monorepo metadata', () => {
+    const testSymlinkTarget = path.join(os.tmpdir(), 'opencli-list-mono-target');
+    const testLink = path.join(PLUGINS_DIR, '__test-mono-list__');
+    beforeEach(() => {
+        // Create a target dir with a command file
+        fs.mkdirSync(testSymlinkTarget, { recursive: true });
+        fs.writeFileSync(path.join(testSymlinkTarget, 'hello.yaml'), 'site: test\nname: hello\n');
+        // Create symlink
+        fs.mkdirSync(PLUGINS_DIR, { recursive: true });
+        try {
+            fs.unlinkSync(testLink);
+        }
+        catch { }
+        fs.symlinkSync(testSymlinkTarget, testLink, 'dir');
+        // Set up lock file with monorepo entry
+        const lock = _readLockFile();
+        lock['__test-mono-list__'] = {
+            source: 'https://github.com/user/test-mono.git',
+            commitHash: 'def456def456def456def456def456def456def4',
+            installedAt: '2025-01-01T00:00:00.000Z',
+            monorepo: { name: 'test-mono', subPath: 'packages/list' },
+        };
+        _writeLockFile(lock);
+    });
+    afterEach(() => {
+        try {
+            fs.unlinkSync(testLink);
+        }
+        catch { }
+        try {
+            fs.rmSync(testSymlinkTarget, { recursive: true, force: true });
+        }
+        catch { }
+        const lock = _readLockFile();
+        delete lock['__test-mono-list__'];
+        _writeLockFile(lock);
+    });
+    it('lists symlinked plugins with monorepoName', () => {
+        const plugins = listPlugins();
+        const found = plugins.find(p => p.name === '__test-mono-list__');
+        expect(found).toBeDefined();
+        expect(found.monorepoName).toBe('test-mono');
+        expect(found.commands).toContain('hello');
+        expect(found.source).toBe('https://github.com/user/test-mono.git');
+    });
+});