gsender

const fs = require('fs');
const path = require('path');
const { run, readJson, isStale } = require('./lib/shell-utils');

const REPO_ROOT = path.resolve(__dirname, '..');
const PLUGINS_ROOT = path.join(REPO_ROOT, 'plugins');
const PLUGIN_SDK_DIR = path.join(REPO_ROOT, 'packages', 'plugin-sdk');
const PLUGIN_SDK_ENTRY = path.join(PLUGIN_SDK_DIR, 'dist', 'index.js');
const PLUGIN_SDK_PACKAGE = '@sienci/gsender-plugin-sdk';

// Inputs that invalidate the SDK's dist/ and a plugin's ui/ respectively.
// Missing paths are ignored, so listing every vite config variant is safe.
const PLUGIN_SDK_SOURCES = ['src', 'package.json', 'tsup.config.ts'].map(
    (entry) => path.join(PLUGIN_SDK_DIR, entry),
);
const PLUGIN_SOURCES = [
    'src',
    'index.html',
    'package.json',
    'gsender-plugin.json',
    'vite.config.js',
    'vite.config.ts',
    'vite.config.mjs',
];

const FORCE = process.env.GSENDER_FORCE_PLUGIN_BUILD === '1';
const STRICT = process.env.GSENDER_STRICT_DEV_PLUGINS === '1';

const detectPackageManager = (dir) =>
    fs.existsSync(path.join(dir, 'yarn.lock')) ? 'yarn' : 'npm';

const install = (dir) => {
    if (detectPackageManager(dir) === 'yarn') {
        run(
            'yarn',
            [
                '--cwd',
                path.relative(REPO_ROOT, dir),
                'install',
                '--non-interactive',
            ],
            REPO_ROOT,
        );
    } else {
        run('npm', ['install'], dir);
    }
};

const ensureDependenciesInstalled = (dir) => {
    if (!fs.existsSync(path.join(dir, 'package.json'))) {
        return;
    }
    if (!FORCE && fs.existsSync(path.join(dir, 'node_modules'))) {
        return;
    }
    install(dir);
};

const ensurePluginSdkBuilt = () => {
    const packageJsonPath = path.join(PLUGIN_SDK_DIR, 'package.json');
    if (!fs.existsSync(packageJsonPath)) {
        return;
    }

    if (!FORCE && !isStale(PLUGIN_SDK_ENTRY, PLUGIN_SDK_SOURCES)) {
        console.log(
            'Plugin SDK is up to date, skipping (set GSENDER_FORCE_PLUGIN_BUILD=1 to force).',
        );
        return;
    }

    console.log('Building @sienci/gsender-plugin-sdk...');
    ensureDependenciesInstalled(PLUGIN_SDK_DIR);
    run(detectPackageManager(PLUGIN_SDK_DIR), ['run', 'build'], PLUGIN_SDK_DIR);
};

// npm links the SDK's `file:` dependency, so those plugins always see the build
// we just made. yarn (and npm in some setups) copies it instead, which freezes
// whatever dist/ existed at install time — the copy then stays on a stale
// bundle and the plugin fails to build against SDK exports added since.
// Re-running the package manager doesn't help: the SDK version is unchanged, so
// yarn just serves the same copy back out of its cache. Refresh it in place.
const refreshCopiedPluginSdk = (pluginDir, name) => {
    const installed = path.join(
        pluginDir,
        'node_modules',
        ...PLUGIN_SDK_PACKAGE.split('/'),
    );

    let stats;
    try {
        stats = fs.lstatSync(installed);
    } catch {
        return; // SDK isn't installed here
    }
    if (stats.isSymbolicLink()) {
        return; // live link — already sees the current build
    }

    if (
        !isStale(path.join(installed, 'dist', 'index.js'), [PLUGIN_SDK_ENTRY])
    ) {
        return;
    }

    console.log(`${name}: refreshing copied plugin SDK.`);
    fs.cpSync(path.join(PLUGIN_SDK_DIR, 'dist'), path.join(installed, 'dist'), {
        recursive: true,
    });
    fs.copyFileSync(
        path.join(PLUGIN_SDK_DIR, 'package.json'),
        path.join(installed, 'package.json'),
    );
};

const discoverPluginDirs = () => {
    if (!fs.existsSync(PLUGINS_ROOT)) {
        return [];
    }

    return fs
        .readdirSync(PLUGINS_ROOT, { withFileTypes: true })
        .filter((entry) => entry.isDirectory())
        .map((entry) => entry.name)
        .filter((name) =>
            fs.existsSync(path.join(PLUGINS_ROOT, name, 'gsender-plugin.json')),
        );
};

const buildPlugin = (name) => {
    const pluginDir = path.join(PLUGINS_ROOT, name);
    const packageJsonPath = path.join(pluginDir, 'package.json');
    if (!fs.existsSync(packageJsonPath)) {
        return;
    }

    const pkg = readJson(packageJsonPath);
    if (!pkg.scripts || !pkg.scripts.build) {
        return;
    }

    ensureDependenciesInstalled(pluginDir);
    refreshCopiedPluginSdk(pluginDir, name);

    const manifest = readJson(path.join(pluginDir, 'gsender-plugin.json'));
    const entry = manifest?.ui?.entry;
    const entryPath = entry ? path.join(pluginDir, entry) : null;
    // The SDK's own output is an input here: a plugin that inlines the SDK
    // carries a copy of it, so a fresh SDK means a stale plugin bundle.
    const sources = [
        ...PLUGIN_SOURCES.map((source) => path.join(pluginDir, source)),
        PLUGIN_SDK_ENTRY,
    ];

    if (!FORCE && entryPath && !isStale(entryPath, sources)) {
        console.log(`${name}: up to date, skipping.`);
        return;
    }

    console.log(`Building plugin: ${name}`);
    run(detectPackageManager(pluginDir), ['run', 'build'], pluginDir);
};

const main = () => {
    ensurePluginSdkBuilt();

    const names = discoverPluginDirs();
    if (names.length === 0) {
        console.log('No plugins found under plugins/. Skipping.');
        return;
    }

    const failed = [];
    names.forEach((name) => {
        try {
            buildPlugin(name);
        } catch (err) {
            console.error(`Failed to build plugin "${name}": ${err.message}`);
            failed.push(name);
        }
    });

    if (failed.length > 0) {
        console.warn(
            `${failed.length} plugin(s) failed to build: ${failed.join(', ')}`,
        );
        if (STRICT) {
            process.exit(1);
        }
    }
};

main();