@zintrust/core 0.4.17 → 0.4.18

package/src/cli/commands/MySqlProxyCommand.js

@@ -0,0 +1,32 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { addSqlProxyOptions, runSqlProxyCommand, } from '../commands/SqlProxyCommandUtils.js';
+import { Env } from '../../config/env.js';
+import { MySqlProxyServer } from '../../proxy/mysql/MySqlProxyServer.js';
+const addOptions = (command) => {
+    addSqlProxyOptions(command, {
+        hostDefault: Env.MYSQL_PROXY_HOST,
+        portDefault: Env.MYSQL_PROXY_PORT,
+        maxBodyBytesDefault: Env.MYSQL_PROXY_MAX_BODY_BYTES,
+        dbVendorLabel: 'MySQL',
+        requireSigningDefault: Env.MYSQL_PROXY_REQUIRE_SIGNING,
+        keyIdDefault: Env.MYSQL_PROXY_KEY_ID,
+        secretDefault: Env.MYSQL_PROXY_SECRET,
+        signingWindowMsDefault: Env.MYSQL_PROXY_SIGNING_WINDOW_MS,
+    });
+};
+export const MySqlProxyCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'proxy:mysql',
+            aliases: ['mysql:proxy', 'mysql-proxy', 'proxy:my'],
+            description: 'Start the MySQL HTTP proxy for Cloudflare Workers',
+            addOptions,
+            execute: async (options) => {
+                await runSqlProxyCommand(options, async (input) => {
+                    await MySqlProxyServer.start(input);
+                });
+            },
+        });
+    },
+});
+export default MySqlProxyCommand;

package/src/cli/commands/NewCommand.d.ts

@@ -0,0 +1,37 @@
+/**
+ * New Command - Project scaffolding CLI command
+ * Handles creation of new ZinTrust projects
+ */
+import type { CommandOptions, IBaseCommand } from '../BaseCommand';
+type TemplateType = 'basic' | 'api' | 'microservice' | 'fullstack';
+type DatabaseType = 'sqlite' | 'mysql' | 'postgresql' | 'mongodb' | 'd1' | 'd1-remote';
+interface NewProjectConfigResult {
+    template: TemplateType;
+    database: DatabaseType;
+    port: number;
+    author: string;
+    description: string;
+}
+type InquirerQuestion = Record<string, unknown>;
+interface INewCommand extends IBaseCommand {
+    promptForConfig(name: string, options: CommandOptions): Promise<NewProjectConfigResult>;
+    getProjectConfig(name: string, options: CommandOptions): Promise<NewProjectConfigResult>;
+    getQuestions(name: string, defaults: NewProjectConfigResult): InquirerQuestion[];
+    getSafeEnv(): NodeJS.ProcessEnv;
+    getGitBinary(): string;
+    runScaffolding(basePath: string, name: string, config: NewProjectConfigResult, overwrite?: boolean): Promise<unknown>;
+    initializeGit(projectPath: string): void;
+    promptForPackageManager(defaultPm: string): Promise<string | null>;
+}
+/**
+ * New Command Factory
+ * Sealed namespace for immutability
+ */
+export declare const NewCommand: Readonly<{
+    /**
+     * Create a new project command instance
+     */
+    create(): INewCommand;
+}>;
+export {};
+//# sourceMappingURL=NewCommand.d.ts.map

package/src/cli/commands/NewCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NewCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/NewCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAgBrE,KAAK,YAAY,GAAG,OAAO,GAAG,KAAK,GAAG,cAAc,GAAG,WAAW,CAAC;AACnE,KAAK,YAAY,GAAG,QAAQ,GAAG,OAAO,GAAG,YAAY,GAAG,SAAS,GAAG,IAAI,GAAG,WAAW,CAAC;AAYvF,UAAU,sBAAsB;IAC9B,QAAQ,EAAE,YAAY,CAAC;IACvB,QAAQ,EAAE,YAAY,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,KAAK,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AA0PhD,UAAU,WAAY,SAAQ,YAAY;IACxC,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACxF,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACzF,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,sBAAsB,GAAG,gBAAgB,EAAE,CAAC;IACjF,UAAU,IAAI,MAAM,CAAC,UAAU,CAAC;IAChC,YAAY,IAAI,MAAM,CAAC;IACvB,cAAc,CACZ,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,sBAAsB,EAC9B,SAAS,CAAC,EAAE,OAAO,GAClB,OAAO,CAAC,OAAO,CAAC,CAAC;IACpB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IACzC,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CACpE;AA8RD;;;GAGG;AACH,eAAO,MAAM,UAAU;IACrB;;OAEG;cACO,WAAW;EAGrB,CAAC"}

package/src/cli/commands/NewCommand.js

@@ -0,0 +1,444 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { PromptHelper } from '../PromptHelper.js';
+import { GovernanceScaffolder } from '../scaffolding/GovernanceScaffolder.js';
+import { ProjectScaffolder } from '../scaffolding/ProjectScaffolder.js';
+import { SpawnUtil } from '../utils/spawn.js';
+import { readEnvString } from '../../common/ExternalServiceUtils.js';
+import { extractErrorMessage, resolvePackageManager } from '../../common/index.js';
+import { appConfig } from '../../config/app.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { execFileSync } from '../../node-singletons/child-process.js';
+import fs from '../../node-singletons/fs.js';
+import * as path from '../../node-singletons/path.js';
+import chalk from 'chalk';
+const getGitBinary = () => 'git';
+const checkGitInstalled = () => {
+    try {
+        execFileSync(getGitBinary(), ['--version'], { stdio: 'ignore', env: appConfig.getSafeEnv() });
+        return true;
+    }
+    catch (error) {
+        ErrorFactory.createCliError('Git check failed', error);
+        return false;
+    }
+};
+const initializeGitRepo = (projectPath, log) => {
+    try {
+        const git = getGitBinary();
+        const env = appConfig.getSafeEnv();
+        execFileSync(git, ['init'], { cwd: projectPath, stdio: 'ignore', env });
+        execFileSync(git, ['add', '.'], { cwd: projectPath, stdio: 'ignore', env });
+        execFileSync(git, ['commit', '-m', 'Initial commit from ZinTrust'], {
+            cwd: projectPath,
+            stdio: 'ignore',
+            env,
+        });
+        log.info('✅ Git repository initialized');
+    }
+    catch (error) {
+        ErrorFactory.createCliError('Git initialization failed', error);
+        log.warn('Could not initialize git repository');
+    }
+};
+const getStringOption = (options, key, fallback) => {
+    const value = options[key];
+    return typeof value === 'string' && value !== '' ? value : fallback;
+};
+const getBooleanOption = (options, key, fallback) => {
+    const value = options[key];
+    return typeof value === 'boolean' ? value : fallback;
+};
+const getProjectDefaults = (name, options) => {
+    const template = getStringOption(options, 'template', 'basic');
+    const normalizeDatabase = (value) => {
+        const v = value.trim();
+        if (v === 'd1-proxy')
+            return 'd1-remote';
+        if (v === 'd1')
+            return 'd1';
+        if (v === 'd1-remote')
+            return 'd1-remote';
+        if (v === 'sqlite')
+            return 'sqlite';
+        if (v === 'mysql')
+            return 'mysql';
+        if (v === 'postgresql' || v === 'postgres')
+            return 'postgresql';
+        if (v === 'mongodb')
+            return 'mongodb';
+        return 'sqlite';
+    };
+    const database = normalizeDatabase(getStringOption(options, 'database', 'sqlite'));
+    const portRaw = getStringOption(options, 'port', '7777');
+    const portParsed = Number.parseInt(portRaw, 10);
+    const port = Number.isFinite(portParsed) && portParsed > 0 ? portParsed : 7777;
+    const author = getStringOption(options, 'author', '');
+    const description = getStringOption(options, 'description', `A new ZinTrust project: ${name}`);
+    const interactive = getBooleanOption(options, 'interactive', true);
+    return { name, template, database, port, author, description, interactive };
+};
+const toConfigResult = (config) => ({
+    template: config.template,
+    database: config.database,
+    port: config.port,
+    author: config.author,
+    description: config.description,
+});
+const getQuestions = (name, defaults) => {
+    return [
+        {
+            type: 'rawlist',
+            name: 'template',
+            message: 'Project template:',
+            choices: ['basic', 'api', 'microservice', 'fullstack'],
+            default: defaults.template,
+        },
+        {
+            type: 'rawlist',
+            name: 'database',
+            message: 'Database driver:',
+            choices: [
+                { name: 'sqlite — Local dev (file-based)', value: 'sqlite' },
+                { name: 'postgresql — Production-ready relational DB', value: 'postgresql' },
+                { name: 'mysql — Production-ready relational DB', value: 'mysql' },
+                { name: 'd1 — Cloudflare D1 database', value: 'd1' },
+                { name: 'd1-proxy — Cloudflare D1 via HTTPS proxy', value: 'd1-remote' },
+                { name: 'mongodb — Document DB (may require additional setup)', value: 'mongodb' },
+            ],
+            default: defaults.database,
+        },
+        {
+            type: 'input',
+            name: 'port',
+            message: 'Default port number:',
+            default: String(defaults.port),
+            validate: (value) => {
+                const port = Number.parseInt(value, 10);
+                return Number.isFinite(port) && port > 0 && port < 65536;
+            },
+        },
+        {
+            type: 'input',
+            name: 'author',
+            message: 'Project author:',
+            default: defaults.author,
+        },
+        {
+            type: 'input',
+            name: 'description',
+            message: 'Project description:',
+            default: defaults.description === '' ? `A new ZinTrust project: ${name}` : defaults.description,
+        },
+    ];
+};
+const mergePromptAnswers = (defaults, answers) => {
+    const template = typeof answers['template'] === 'string'
+        ? answers['template']
+        : defaults.template;
+    const database = typeof answers['database'] === 'string'
+        ? answers['database']
+        : defaults.database;
+    let port = defaults.port;
+    const portAnswer = answers['port'];
+    if (typeof portAnswer === 'string') {
+        const parsed = Number.parseInt(portAnswer, 10);
+        if (Number.isFinite(parsed))
+            port = parsed;
+    }
+    else if (typeof portAnswer === 'number') {
+        if (Number.isFinite(portAnswer))
+            port = portAnswer;
+    }
+    const author = typeof answers['author'] === 'string' ? answers['author'] : defaults.author;
+    const description = typeof answers['description'] === 'string' ? answers['description'] : defaults.description;
+    return {
+        ...defaults,
+        template,
+        database,
+        port,
+        author,
+        description,
+    };
+};
+const promptForConfig = async (name, options) => {
+    const defaults = getProjectDefaults(name, options);
+    if (defaults.interactive === false)
+        return defaults;
+    const questions = getQuestions(name, defaults);
+    const answers = await PromptHelper.prompt(questions);
+    return mergePromptAnswers(defaults, answers);
+};
+const isFailureResult = (result) => {
+    if (typeof result !== 'object' || result === null)
+        return false;
+    const maybe = result;
+    return maybe.success === false;
+};
+const promptForPackageManager = async (defaultPm) => {
+    const choices = [
+        { name: 'npm', value: 'npm' },
+        { name: 'yarn', value: 'yarn' },
+        { name: 'pnpm', value: 'pnpm' },
+        { name: 'bun', value: 'bun' },
+        { name: 'Skip installation', value: null },
+    ];
+    const answer = await PromptHelper.prompt([
+        {
+            type: 'rawlist',
+            name: 'packageManager',
+            message: 'Select package manager for dependency installation:',
+            choices,
+            default: defaultPm,
+        },
+    ]);
+    if (typeof answer !== 'object' || answer === null)
+        return null;
+    return answer['packageManager'] ?? null;
+};
+const installDependencies = async (projectPath, log, packageManager, force = false) => {
+    // Respect CI by default — avoid network installs in CI unless explicitly allowed
+    const ciRaw = readEnvString('CI').trim().toLowerCase();
+    const isCi = ciRaw !== '' && ciRaw !== '0' && ciRaw !== 'false';
+    const allowAuto = readEnvString('ZINTRUST_ALLOW_AUTO_INSTALL') === '1' || force;
+    if (isCi && !allowAuto) {
+        log.info('Skipping automatic dependency installation in CI environment.');
+        return;
+    }
+    if (packageManager === null) {
+        log.info('⏭️  Skipping dependency installation (not selected).');
+        return;
+    }
+    log.info('📦 Installing dependencies (this may take a minute)...');
+    const pm = packageManager ?? resolvePackageManager();
+    const args = ['install'];
+    try {
+        const exitCode = await SpawnUtil.spawnAndWait({ command: pm, args, cwd: projectPath });
+        if (exitCode !== 0) {
+            throw ErrorFactory.createCliError(`'${pm} install' failed with exit code ${exitCode}`);
+        }
+        log.info('✅ Dependencies installed successfully');
+    }
+    catch (error) {
+        ErrorFactory.createCliError('Dependency installation failed', error);
+        log.warn(`Please run "${pm} install" manually in the project directory`);
+    }
+};
+const addOptions = (command) => {
+    command.argument('<name>', 'Project name');
+    command.option('--template <type>', 'Project template (basic, api, microservice, fullstack)', 'basic');
+    command.option('--database <type>', 'Database driver (sqlite, mysql, postgresql, d1, d1-remote, mongodb)', 'sqlite');
+    command.option('--port <number>', 'Default port number', '7777');
+    command.option('--author <name>', 'Project author');
+    command.option('--description <text>', 'Project description');
+    command.option('--interactive', 'Run in interactive mode', true);
+    command.option('--no-interactive', 'Disable interactive mode');
+    command.option('--no-git', 'Skip git initialization');
+    command.option('--no-install', 'Skip dependency installation');
+    command.option('--install', 'Force dependency installation (useful to override CI defaults)');
+    command.option('--package-manager <manager>', 'Package manager to use (npm, yarn, pnpm)');
+    command.option('--governance', 'Install governance tooling (ESLint + architecture tests)', false);
+    command.option('--with-d1-proxy', 'Add @zintrust/cloudflare-d1-proxy to package.json (for deploying the D1 proxy worker)', false);
+    command.option('--force', 'Overwrite existing directory');
+    command.option('--overwrite', 'Overwrite existing directory');
+};
+const maybeAddD1ProxyDependency = (projectPath, options, log) => {
+    const enabled = options['withD1Proxy'] === true || options['with-d1-proxy'] === true;
+    if (!enabled)
+        return;
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        log.warn(`Could not add @zintrust/cloudflare-d1-proxy (missing package.json at ${packageJsonPath})`);
+        return;
+    }
+    try {
+        const raw = fs.readFileSync(packageJsonPath, 'utf8');
+        const pkg = JSON.parse(raw);
+        const dependencies = { ...pkg.dependencies };
+        if (typeof dependencies['@zintrust/cloudflare-d1-proxy'] !== 'string') {
+            // Avoid pinning to core version (they can differ). Use a safe caret range.
+            dependencies['@zintrust/cloudflare-d1-proxy'] = '^0.1.42';
+        }
+        const next = {
+            ...pkg,
+            dependencies,
+        };
+        fs.writeFileSync(packageJsonPath, JSON.stringify(next, null, 2) + '\n');
+        log.info('✅ Added @zintrust/cloudflare-d1-proxy to dependencies');
+    }
+    catch (error) {
+        ErrorFactory.createCliError('Failed to update package.json with D1 proxy dependency', error);
+        log.warn('Please add @zintrust/cloudflare-d1-proxy manually if you need the proxy worker.');
+    }
+};
+const resolveProjectName = async (options) => {
+    const argName = options.args?.[0];
+    const projectName = argName ?? (await PromptHelper.projectName('my-zintrust-app', true));
+    if (!projectName)
+        throw ErrorFactory.createCliError('Project name is required');
+    return projectName;
+};
+const resolveProjectTarget = async (options) => {
+    const input = await resolveProjectName(options);
+    const isPathLike = input.includes('/') || input.includes('\\');
+    if (!isPathLike) {
+        return {
+            basePath: process.cwd(),
+            name: input,
+            projectPath: path.resolve(process.cwd(), input),
+            display: input,
+            cdPath: input,
+        };
+    }
+    const projectPath = path.resolve(process.cwd(), input);
+    const name = path.basename(projectPath);
+    const basePath = path.dirname(projectPath);
+    const cdPath = input.startsWith('/') ? projectPath : input;
+    return {
+        basePath,
+        name,
+        projectPath,
+        display: input,
+        cdPath,
+    };
+};
+const createProject = async (target, options, command) => {
+    const config = await command.getProjectConfig(target.name, options);
+    command.info(chalk.bold(`\n🚀 Creating new ZinTrust project in ${target.display}...\n`));
+    const overwrite = options['overwrite'] === true || options['force'] === true ? true : undefined;
+    const result = await command.runScaffolding(target.basePath, target.name, config, overwrite);
+    if (isFailureResult(result)) {
+        throw ErrorFactory.createCliError(result.message ?? 'Project scaffolding failed', result);
+    }
+    if (options['governance'] === true) {
+        const gov = await GovernanceScaffolder.scaffold(target.projectPath, {
+            writeEslintConfig: true,
+            writeArchTests: true,
+            install: false,
+        });
+        if (gov.success === false) {
+            throw ErrorFactory.createCliError(gov.message ?? 'Governance scaffolding failed', gov);
+        }
+    }
+    // Optional dependency injection must happen before `npm/yarn/pnpm install`.
+    maybeAddD1ProxyDependency(target.projectPath, options, command);
+};
+const maybeInitializeGit = (options, command, target) => {
+    if (options['git'] !== false) {
+        command.initializeGit(target.projectPath);
+    }
+};
+const maybeInstallDependencies = async (options, command, target) => {
+    if (options['install'] === false)
+        return;
+    const projectPath = target.projectPath;
+    let pm = options['packageManager'] ??
+        options['package-manager'];
+    // If no package manager specified and not in non-interactive mode, prompt user
+    if (pm === undefined && options['interactive'] !== false && options['no-interactive'] !== true) {
+        const defaultPm = resolvePackageManager();
+        const selectedPm = await command.promptForPackageManager(defaultPm);
+        if (selectedPm === null) {
+            command.info('⏭️  Skipping dependency installation.');
+            pm = '__skip__'; // Signal to skip installation
+        }
+        else {
+            pm = selectedPm;
+        }
+    }
+    const force = options['install'] === true;
+    if (pm === '__skip__')
+        return;
+    const effectivePm = pm ?? resolvePackageManager();
+    await installDependencies(projectPath, command, pm, force);
+    return effectivePm;
+};
+const executeNewCommand = async (options, command) => {
+    try {
+        const target = await resolveProjectTarget(options);
+        await createProject(target, options, command);
+        maybeInitializeGit(options, command, target);
+        await maybeInstallDependencies(options, command, target);
+        command.success(`\n✨ Project ${target.name} created successfully!`);
+        const runDevCmd = 'zin start';
+        command.info(`\nNext steps:\n  cd ${target.cdPath}\n  ${runDevCmd}\n`);
+    }
+    catch (error) {
+        throw ErrorFactory.createCliError(`Project creation failed: ${extractErrorMessage(error)}`, error);
+    }
+};
+const createNewCommandInstance = () => {
+    // BaseCommand.getCommand() closes over the execute callback passed at creation time.
+    // NewCommand needs its final implementation (which depends on the constructed instance),
+    // so we use a mutable indirection.
+    let executeImpl = async () => {
+        // replaced below with NewCommand-aware execute implementation
+    };
+    const base = BaseCommand.create({
+        name: 'new',
+        description: 'Create a new ZinTrust project',
+        addOptions,
+        execute: async (options) => {
+            await executeImpl(options);
+        },
+    });
+    const commandInstance = {
+        ...base,
+        promptForConfig: async (name, options) => {
+            const config = await promptForConfig(name, options);
+            return toConfigResult(config);
+        },
+        getSafeEnv: () => appConfig.getSafeEnv(),
+        getGitBinary: () => getGitBinary(),
+        getQuestions: (name, defaults) => {
+            const fullDefaults = {
+                name,
+                template: defaults.template,
+                database: defaults.database,
+                port: defaults.port,
+                author: defaults.author,
+                description: defaults.description,
+                interactive: true,
+            };
+            return getQuestions(name, fullDefaults);
+        },
+        getProjectConfig: async (name, options) => {
+            return commandInstance.promptForConfig(name, options);
+        },
+        runScaffolding: async (basePath, name, config, overwrite) => {
+            return ProjectScaffolder.scaffold(basePath, {
+                name,
+                force: overwrite === true,
+                template: config.template,
+                database: config.database,
+                port: config.port,
+                author: config.author,
+                description: config.description,
+            });
+        },
+        initializeGit: (projectPath) => {
+            if (checkGitInstalled()) {
+                initializeGitRepo(projectPath, commandInstance);
+            }
+        },
+        promptForPackageManager: async (defaultPm) => {
+            return promptForPackageManager(defaultPm);
+        },
+        execute: async (options) => {
+            await executeNewCommand(options, commandInstance);
+        },
+    };
+    executeImpl = commandInstance.execute;
+    return commandInstance;
+};
+/**
+ * New Command Factory
+ * Sealed namespace for immutability
+ */
+export const NewCommand = Object.freeze({
+    /**
+     * Create a new project command instance
+     */
+    create() {
+        return createNewCommandInstance();
+    },
+});

package/src/cli/commands/NotificationWorkCommand.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Notification Work Command
+ * Alias to work a notification queue.
+ */
+import { type IBaseCommand } from '../BaseCommand';
+export declare const NotificationWorkCommand: Readonly<{
+    create(): IBaseCommand;
+}>;
+export default NotificationWorkCommand;
+//# sourceMappingURL=NotificationWorkCommand.d.ts.map

package/src/cli/commands/NotificationWorkCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotificationWorkCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/NotificationWorkCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAGrD,eAAO,MAAM,uBAAuB;cACxB,YAAY;EAQtB,CAAC;AAEH,eAAe,uBAAuB,CAAC"}

package/src/cli/commands/NotificationWorkCommand.js

@@ -0,0 +1,16 @@
+/**
+ * Notification Work Command
+ * Alias to work a notification queue.
+ */
+import { createKindWorkCommand } from '../commands/createKindWorkCommand.js';
+export const NotificationWorkCommand = Object.freeze({
+    create() {
+        return createKindWorkCommand({
+            name: 'notification:work',
+            description: 'Work queued notifications',
+            kind: 'notification',
+            helpHint: 'zin notification:work --help',
+        });
+    },
+});
+export default NotificationWorkCommand;

package/src/cli/commands/PluginCommand.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Plugin Command
+ * Manage framework plugins (install, uninstall, list)
+ */
+import type { IBaseCommand } from '../BaseCommand';
+export declare const PluginCommand: Readonly<{
+    create(): IBaseCommand;
+}>;
+//# sourceMappingURL=PluginCommand.d.ts.map

package/src/cli/commands/PluginCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/PluginCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAMrE,eAAO,MAAM,aAAa;cACd,YAAY;EAuDtB,CAAC"}

package/src/cli/commands/PluginCommand.js

@@ -0,0 +1,98 @@
+/**
+ * Plugin Command
+ * Manage framework plugins (install, uninstall, list)
+ */
+import { BaseCommand } from '../BaseCommand.js';
+import { Logger } from '../../config/logger.js';
+import { PluginManager } from '../../runtime/PluginManager.js';
+export const PluginCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'plugin',
+            description: 'Manage framework plugins',
+            addOptions: (command) => {
+                command.alias('p');
+                // Options for short syntax (zin p -i a:sqlite)
+                command.option('-i, --install <pluginId>', 'Install a plugin');
+                command.option('-u, --uninstall <pluginId>', 'Uninstall a plugin');
+                command.option('-l, --list', 'List available plugins');
+                command
+                    .command('list')
+                    .alias('ls')
+                    .description('List available plugins')
+                    .action(async () => {
+                    await listPlugins();
+                });
+                command
+                    .command('install <pluginId>')
+                    .alias('i')
+                    .description('Install a plugin')
+                    .option('--package-manager <pm>', 'Specify package manager to use (npm|yarn|pnpm)')
+                    .action(async (pluginId, options) => {
+                    await installPlugin(pluginId, options);
+                });
+                command
+                    .command('uninstall <pluginId>')
+                    .alias('un')
+                    .description('Uninstall a plugin')
+                    .action(async (pluginId) => {
+                    await uninstallPlugin(pluginId);
+                });
+            },
+            execute: async (options) => {
+                const installId = options['install'];
+                const uninstallId = options['uninstall'];
+                const shouldList = options['list'];
+                if (typeof installId === 'string' && installId.length > 0) {
+                    await installPlugin(installId);
+                }
+                else if (typeof uninstallId === 'string' && uninstallId.length > 0) {
+                    await uninstallPlugin(uninstallId);
+                }
+                else if (shouldList === true) {
+                    await listPlugins();
+                }
+                else {
+                    Logger.info('Use "plugin list", "plugin install <id>", or "plugin uninstall <id>"');
+                    Logger.info('Shortcuts: "zin p -l", "zin p -i <id>", "zin p -u <id>"');
+                }
+            },
+        });
+    },
+});
+async function listPlugins() {
+    const plugins = PluginManager.list();
+    Logger.info('Available Plugins:');
+    const pluginEntries = Object.entries(plugins);
+    const installedStatuses = await Promise.all(pluginEntries.map(async ([id]) => PluginManager.isInstalled(id)));
+    for (let i = 0; i < pluginEntries.length; i++) {
+        const [id, plugin] = pluginEntries[i];
+        const isInstalled = installedStatuses[i] ?? false;
+        const status = isInstalled ? '✓ Installed' : '- Available';
+        const aliases = plugin.aliases !== undefined && plugin.aliases.length > 0
+            ? `(aliases: ${plugin.aliases.join(', ')})`
+            : '';
+        Logger.info(`  ${id.padEnd(20)} ${status.padEnd(15)} ${plugin.description} ${aliases}`);
+    }
+}
+async function installPlugin(pluginId, options) {
+    try {
+        const pm = typeof options?.['packageManager'] === 'string'
+            ? String(options?.['packageManager'])
+            : undefined;
+        await PluginManager.install(pluginId, { packageManager: pm });
+    }
+    catch (error) {
+        Logger.error(`Failed to install plugin ${pluginId}`, error);
+        process.exit(1);
+    }
+}
+async function uninstallPlugin(pluginId) {
+    try {
+        await PluginManager.uninstall(pluginId);
+    }
+    catch (error) {
+        Logger.error(`Failed to uninstall plugin ${pluginId}`, error);
+        process.exit(1);
+    }
+}

package/src/cli/commands/PostgresProxyCommand.d.ts

@@ -0,0 +1,6 @@
+import type { IBaseCommand } from '../BaseCommand';
+export declare const PostgresProxyCommand: Readonly<{
+    create(): IBaseCommand;
+}>;
+export default PostgresProxyCommand;
+//# sourceMappingURL=PostgresProxyCommand.d.ts.map

package/src/cli/commands/PostgresProxyCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresProxyCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/PostgresProxyCommand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA0BrE,eAAO,MAAM,oBAAoB;cACrB,YAAY;EAatB,CAAC;AAEH,eAAe,oBAAoB,CAAC"}