@zintrust/core 0.1.28 → 0.1.29

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

@@ -0,0 +1,7 @@
+/**
+ * Queue Lock Command Extensions
+ * Implements CLI commands for managing queue locks and deduplication
+ */
+import type { Command } from 'commander';
+export declare function setupQueueLockCommands(command: Command): void;
+//# sourceMappingURL=QueueLockCommand.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"QueueLockCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/QueueLockCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA2IzC,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAK7D"}

package/src/cli/commands/QueueLockCommand.js

@@ -0,0 +1,138 @@
+/**
+ * Queue Lock Command Extensions
+ * Implements CLI commands for managing queue locks and deduplication
+ */
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { ZintrustLang } from '../../lang/lang.js';
+import { Logger } from '../../config/logger.js';
+import { createAdvancedQueue } from '../../tools/queue/AdvancedQueue.js';
+import { getLockProvider } from '../../tools/queue/LockProvider.js';
+// Reusing initialization logic from AdvancedQueue
+// But we need direct access to lock provider for maintenance
+// AdvancedQueue only exposes limited interface
+function getProvider(providerName = 'redis') {
+    // Create proper QueueConfig object that matches the expected interface
+    const advancedQueueConfig = {
+        name: ZintrustLang.CLI_LOCKS,
+        connection: undefined, // No specific connection needed for CLI operations
+        defaultDedupTtl: ZintrustLang.ZINTRUST_LOCKS_TTL,
+        lockProvider: providerName,
+    };
+    // Need to ensure provider is registered. creating AdvancedQueue triggers registration.
+    createAdvancedQueue(advancedQueueConfig);
+    const provider = getLockProvider(providerName);
+    if (!provider) {
+        throw ErrorFactory.createCliError(`Lock provider '${providerName}' not found.`);
+    }
+    return provider;
+}
+const setupLockListCommand = (command) => {
+    command
+        .command('lock:list')
+        .description('List active deduplication locks')
+        .option('--pattern <pattern>', 'Key pattern to match (default: *)', '*')
+        .option('--provider <name>', 'Lock provider name (default: redis)', 'redis')
+        .action(async (options) => {
+        try {
+            const provider = getProvider(options.provider);
+            const locks = await provider.list(options?.pattern ?? '*');
+            if (locks.length === 0) {
+                Logger.info('No locks found.');
+                return;
+            }
+            Logger.info(`Found ${locks.length} locks:`);
+            // Batch all status checks for better performance
+            const statusPromises = locks.map(async (key) => {
+                const status = await provider.status(key);
+                const expires = status.expires ? status.expires.toISOString() : 'never';
+                const ttl = typeof status.ttl === 'number' ? `${Math.round(status.ttl / 1000)}s` : 'unknown';
+                return { key, ttl, expires };
+            });
+            const lockStatuses = await Promise.all(statusPromises);
+            for (const { key, ttl, expires } of lockStatuses) {
+                Logger.info(`- [${key}] (TTL: ${ttl}, Expires: ${expires})`);
+            }
+        }
+        catch (error) {
+            Logger.error('Failed to list locks', error);
+        }
+    });
+};
+const setupLockReleaseCommand = (command) => {
+    command
+        .command('lock:release <key>')
+        .description('Manually release a deduplication lock')
+        .option('--provider <name>', 'Lock provider name (default: redis)', 'redis')
+        .action(async (key, options) => {
+        try {
+            const provider = getProvider(options.provider);
+            const status = await provider.status(key);
+            if (!status.exists) {
+                Logger.info(`Lock '${key}' does not exist.`);
+                return;
+            }
+            await provider.release({ key, ttl: 0, acquired: true, expires: new Date() });
+            Logger.info(`Lock '${key}' released successfully.`);
+        }
+        catch (error) {
+            Logger.error(`Failed to release lock ${key}`, error);
+        }
+    });
+};
+const setupLockExtendCommand = (command) => {
+    command
+        .command('lock:extend <key> <seconds>')
+        .description('Extend TTL of an existing lock')
+        .option('--provider <name>', 'Lock provider name (default: redis)', 'redis')
+        .action(async (key, seconds, options) => {
+        try {
+            const ttl = Number.parseInt(seconds, 10) * 1000;
+            const provider = getProvider(options.provider);
+            // Mock lock object for extension
+            const lock = { key, ttl: 0, acquired: true, expires: new Date() };
+            const extended = await provider.extend(lock, ttl);
+            if (extended) {
+                Logger.info(`Lock '${key}' extended by ${seconds} seconds.`);
+            }
+            else {
+                Logger.info(`Failed to extend lock '${key}' (may not exist).`);
+            }
+        }
+        catch (error) {
+            Logger.error(`Failed to extend lock ${key}`, error);
+        }
+    });
+};
+const setupDedupeStatusCommand = (command) => {
+    command
+        .command('dedupe:status <id>')
+        .description('Check deduplication status of a job ID')
+        .option('--provider <name>', 'Lock provider name (default: redis)', 'redis')
+        .action(async (id, options) => {
+        try {
+            const provider = getProvider(options.provider);
+            const status = await provider.status(id);
+            if (status.exists) {
+                Logger.info(`Job ID '${id}' is currently LOCKED (Deduplicated).`);
+                const ttlMs = status.ttl;
+                const ttlSeconds = ttlMs !== null && ttlMs !== undefined && !Number.isNaN(ttlMs) && ttlMs > 0
+                    ? Math.round(ttlMs / 1000) + 's'
+                    : 'unknown';
+                Logger.info(`TTL Remaining: ${ttlSeconds}`);
+                Logger.info(`Expires At: ${status.expires ? status.expires.toISOString() : 'unknown'}`);
+            }
+            else {
+                Logger.info(`Job ID '${id}' is NOT locked (Ready for processing or expired).`);
+            }
+        }
+        catch (error) {
+            Logger.error(`Failed to check status for ${id}`, error);
+        }
+    });
+};
+export function setupQueueLockCommands(command) {
+    setupLockListCommand(command);
+    setupLockReleaseCommand(command);
+    setupLockExtendCommand(command);
+    setupDedupeStatusCommand(command);
+}

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

@@ -0,0 +1,10 @@
+import { type QueueWorkRunnerResult } from '../workers/QueueWorkRunner';
+export declare const QueueWorkCommandUtils: Readonly<{
+    parsePositiveInt: (value: unknown, flag: string) => number | undefined;
+    parseNonNegativeInt: (value: unknown, flag: string) => number | undefined;
+    normalizeDriverName: (value: unknown) => string | undefined;
+    requireQueueNameFromArgs: (args: unknown[] | undefined, helpHint: string) => string;
+    logSummary: (queueName: string, kindLabel: string, result: QueueWorkRunnerResult) => void;
+}>;
+export default QueueWorkCommandUtils;
+//# sourceMappingURL=QueueWorkCommandUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"QueueWorkCommandUtils.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/QueueWorkCommandUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAI1E,eAAO,MAAM,qBAAqB;8BACN,OAAO,QAAQ,MAAM,KAAG,MAAM,GAAG,SAAS;iCAcvC,OAAO,QAAQ,MAAM,KAAG,MAAM,GAAG,SAAS;iCAc1C,OAAO,KAAG,MAAM,GAAG,SAAS;qCAKxB,OAAO,EAAE,GAAG,SAAS,YAAY,MAAM,KAAG,MAAM;4BAQzD,MAAM,aAAa,MAAM,UAAU,qBAAqB,KAAG,IAAI;EAKvF,CAAC;AAEH,eAAe,qBAAqB,CAAC"}

package/src/cli/commands/QueueWorkCommandUtils.js

@@ -0,0 +1,43 @@
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+export const QueueWorkCommandUtils = Object.freeze({
+    parsePositiveInt: (value, flag) => {
+        if (value === undefined)
+            return undefined;
+        const raw = String(value).trim();
+        if (raw === '')
+            return undefined;
+        const n = Number.parseInt(raw, 10);
+        if (!Number.isFinite(n) || n <= 0) {
+            throw ErrorFactory.createCliError(`Error: Invalid ${flag} '${raw}'. Expected a positive integer.`);
+        }
+        return n;
+    },
+    parseNonNegativeInt: (value, flag) => {
+        if (value === undefined)
+            return undefined;
+        const raw = String(value).trim();
+        if (raw === '')
+            return undefined;
+        const n = Number.parseInt(raw, 10);
+        if (!Number.isFinite(n) || n < 0) {
+            throw ErrorFactory.createCliError(`Error: Invalid ${flag} '${raw}'. Expected a non-negative integer.`);
+        }
+        return n;
+    },
+    normalizeDriverName: (value) => {
+        const raw = typeof value === 'string' ? value.trim() : '';
+        return raw === '' ? undefined : raw;
+    },
+    requireQueueNameFromArgs: (args, helpHint) => {
+        const queueName = typeof args?.[0] === 'string' ? String(args[0]) : '';
+        if (queueName.trim() === '') {
+            throw ErrorFactory.createCliError(`Error: Missing <queueName>. Try '${helpHint}'.`);
+        }
+        return queueName;
+    },
+    logSummary: (queueName, kindLabel, result) => {
+        Logger.info(`Queue work complete (${kindLabel}) for '${queueName}': processed=${result.processed} retried=${result.retried} dropped=${result.dropped} notDueRequeued=${result.notDueRequeued} unknown=${result.unknown}`);
+    },
+});
+export default QueueWorkCommandUtils;

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

@@ -0,0 +1,6 @@
+/**
+ * Resource Control Command
+ * Control the resource monitor (start/stop) on the running worker service via HTTP
+ */
+export declare const ResourceControlCommand: import("../BaseCommand").IBaseCommand;
+//# sourceMappingURL=ResourceControlCommand.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ResourceControlCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/ResourceControlCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,eAAO,MAAM,sBAAsB,yCAuCjC,CAAC"}

package/src/cli/commands/ResourceControlCommand.js

@@ -0,0 +1,43 @@
+/**
+ * Resource Control Command
+ * Control the resource monitor (start/stop) on the running worker service via HTTP
+ */
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { BaseCommand } from '../BaseCommand.js';
+import { Logger } from '../../config/logger.js';
+export const ResourceControlCommand = BaseCommand.create({
+    name: 'resource:monitor',
+    description: 'Control the resource monitor (start/stop) on the running worker service',
+    aliases: ['rm'],
+    addOptions: (cmd) => {
+        cmd.argument('<action>', 'Action to perform: start or stop');
+        cmd.option('--port <port>', 'Worker service port', '7777');
+        cmd.option('--host <host>', 'Worker service host', '127.0.0.1');
+    },
+    execute: async (options) => {
+        const action = options.args?.[0];
+        const port = options['port'] ?? '7777';
+        const host = options['host'] ?? '127.0.0.1';
+        if (action === undefined || !['start', 'stop'].includes(action)) {
+            Logger.error('Invalid action. Use "start" or "stop".');
+            return;
+        }
+        const url = `http://${host}:${port}/api/resources/${action}`;
+        try {
+            Logger.info(`Sending ${action} request to ${url}...`);
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+            });
+            if (!response.ok) {
+                throw ErrorFactory.createCliError(`HTTP ${response.status}: ${await response.text()}`);
+            }
+            const data = (await response.json());
+            Logger.info(`Success: ${data.message}`);
+        }
+        catch (e) {
+            Logger.error(`Failed to ${action} resource monitor: ${e.message}`);
+            Logger.info('Ensure the worker service is running and the port is correct.');
+        }
+    },
+});

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

@@ -0,0 +1,10 @@
+/**
+ * Routes Command
+ * Lists all registered routes in a table.
+ */
+import { type IBaseCommand } from '../BaseCommand';
+export declare const RoutesCommand: Readonly<{
+    create(): IBaseCommand;
+}>;
+export default RoutesCommand;
+//# sourceMappingURL=RoutesCommand.d.ts.map

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

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

package/src/cli/commands/RoutesCommand.js

@@ -0,0 +1,251 @@
+/**
+ * Routes Command
+ * Lists all registered routes in a table.
+ */
+import { BaseCommand } from '../BaseCommand.js';
+import { Env } from '../../config/env.js';
+import { Router } from '../../routes/Router.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+const parseGroupBy = (value) => {
+    const raw = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    if (raw === '' || raw === 'group')
+        return 'group';
+    if (raw === 'service')
+        return 'service';
+    if (raw === 'none')
+        return 'none';
+    throw ErrorFactory.createCliError(`Invalid --group-by '${String(value)}'. Expected: group | service | none.`);
+};
+const parseMethodFilter = (value) => {
+    const raw = typeof value === 'string' ? value.trim() : '';
+    if (raw === '')
+        return null;
+    const items = raw
+        .split(',')
+        .map((s) => s.trim().toUpperCase())
+        .filter((s) => s.length > 0);
+    return items.length === 0 ? null : new Set(items);
+};
+const normalizeHandlerName = (handler) => {
+    const name = typeof handler === 'function' &&
+        typeof handler.name === 'string'
+        ? handler.name
+        : '';
+    if (name.trim() === '')
+        return '<anonymous>';
+    return name.startsWith('bound ') ? name.slice('bound '.length) : name;
+};
+const normalizePath = (path) => (typeof path === 'string' ? path : '');
+const normalizePathForUrl = (path) => {
+    const raw = path.trim();
+    if (raw === '')
+        return '/';
+    const withLeadingSlash = raw.startsWith('/') ? raw : `/${raw}`;
+    // Avoid accidental double slashes when Router.group prefixes with '/api/v1' and child route starts with '/'
+    return withLeadingSlash.replaceAll(/\/+/g, '/');
+};
+const getBaseOrigin = () => {
+    const baseUrlRaw = Env.get('BASE_URL', Env.BASE_URL ?? '').trim();
+    const port = Env.getInt('PORT', typeof Env.PORT === 'number' && Number.isFinite(Env.PORT) ? Env.PORT : 0);
+    // Treat empty or path-only values as "unset" (avoid weird results like ":3000")
+    if (baseUrlRaw === '' || baseUrlRaw === '/' || baseUrlRaw.startsWith('/'))
+        return '';
+    const withScheme = baseUrlRaw.includes('://') ? baseUrlRaw : `http://${baseUrlRaw}`;
+    try {
+        const url = new URL(withScheme);
+        if (url.port === '' && port > 0) {
+            url.port = String(port);
+        }
+        return url.origin;
+    }
+    catch {
+        // Fallback: best-effort string join
+        const noTrailingSlash = baseUrlRaw.endsWith('/') ? baseUrlRaw.slice(0, -1) : baseUrlRaw;
+        if (noTrailingSlash === '')
+            return '';
+        return port > 0 && !noTrailingSlash.includes(':')
+            ? `${noTrailingSlash}:${port}`
+            : noTrailingSlash;
+    }
+};
+const buildFullUrl = (origin, path) => {
+    if (origin.trim() === '')
+        return path;
+    const cleanOrigin = origin.endsWith('/') ? origin.slice(0, -1) : origin;
+    const cleanPath = normalizePathForUrl(path);
+    return `${cleanOrigin}${cleanPath}`;
+};
+const deriveGroup = (path) => {
+    if (path === '/' || path.trim() === '')
+        return '/';
+    const parts = path.split('/').filter(Boolean);
+    if (parts.length === 0)
+        return '/';
+    // Prefer deeper groups for common API patterns
+    if (parts[0] === 'api' && parts[1] !== undefined)
+        return `/api/${parts[1]}`;
+    return `/${parts[0]}`;
+};
+const deriveService = (path) => {
+    if (path === '/' || path.trim() === '')
+        return '/';
+    const parts = path.split('/').filter(Boolean);
+    if (parts.length === 0)
+        return '/';
+    // For /api/v1/<service>/... group by <service>
+    if (parts[0] === 'api' && parts[1] !== undefined) {
+        const service = parts[2] ?? parts[1];
+        return service === '' ? `/api/${parts[1]}` : service;
+    }
+    return parts[0];
+};
+const partitionMiddleware = (names) => {
+    const validations = [];
+    const middleware = [];
+    for (const name of names) {
+        if (name.toLowerCase().startsWith('validate')) {
+            validations.push(name);
+        }
+        else {
+            middleware.push(name);
+        }
+    }
+    return { middleware, validations };
+};
+const unique = (items) => Array.from(new Set(items));
+const truncate = (value, max) => {
+    if (value.length <= max)
+        return value;
+    if (max <= 1)
+        return value.slice(0, max);
+    return `${value.slice(0, Math.max(0, max - 1))}…`;
+};
+const pad = (value, width) => value.padEnd(width);
+const renderTable = (rows) => {
+    /* eslint-disable no-console */
+    const columns = [
+        { key: 'url', title: 'URL', max: 64 },
+        { key: 'group', title: 'Group', max: 18 },
+        { key: 'method', title: 'Method', max: 6 },
+        { key: 'path', title: 'Path', max: 42 },
+        { key: 'middleware', title: 'Middleware', max: 28 },
+        { key: 'validations', title: 'Validation', max: 24 },
+        { key: 'handler', title: 'Handler', max: 28 },
+    ];
+    const widths = Object.fromEntries(columns.map((c) => {
+        const contentMax = Math.max(c.title.length, ...rows.map((r) => truncate(String(r[c.key] ?? ''), c.max).length));
+        return [c.key, Math.min(c.max, Math.max(4, contentMax))];
+    }));
+    const border = `┌${columns.map((c) => '─'.repeat(widths[c.key] + 2)).join('┬')}┐`;
+    const mid = `├${columns.map((c) => '─'.repeat(widths[c.key] + 2)).join('┼')}┤`;
+    const bottom = `└${columns.map((c) => '─'.repeat(widths[c.key] + 2)).join('┴')}┘`;
+    const header = `│${columns
+        .map((c) => ` ${pad(truncate(c.title, widths[c.key]), widths[c.key])} `)
+        .join('│')}│`;
+    console.log(border);
+    console.log(header);
+    console.log(mid);
+    for (const row of rows) {
+        const line = `│${columns
+            .map((c) => {
+            const cell = truncate(String(row[c.key] ?? ''), widths[c.key]);
+            return ` ${pad(cell, widths[c.key])} `;
+        })
+            .join('│')}│`;
+        console.log(line);
+    }
+    console.log(bottom);
+    /* eslint-enable no-console */
+};
+const buildRows = async (options) => {
+    const groupBy = parseGroupBy(options.groupBy);
+    const filterText = typeof options.filter === 'string' ? options.filter.trim().toLowerCase() : '';
+    const methodFilter = parseMethodFilter(options.method);
+    const baseOrigin = getBaseOrigin();
+    const router = Router.createRouter();
+    // 1. Always load core framework routes (health, metrics, doc, error pages)
+    const { registerCoreRoutes } = await import('../../routes/CoreRoutes.js');
+    registerCoreRoutes(router);
+    // 2. Try to load application routes if available
+    try {
+        const { registerRoutes } = await import('../../../routes/api.js');
+        registerRoutes(router);
+    }
+    catch {
+        // routes/api.ts not found, continue with just core routes
+    }
+    const routes = Router.getRoutes(router);
+    const rows = routes.map((route) => {
+        const path = normalizePath(route.path);
+        let group = '';
+        if (groupBy === 'service') {
+            group = deriveService(path);
+        }
+        else if (groupBy === 'group') {
+            group = deriveGroup(path);
+        }
+        const mwNames = Array.isArray(route.middleware)
+            ? route.middleware.filter((m) => typeof m === 'string')
+            : [];
+        const mw = partitionMiddleware(unique(mwNames));
+        return {
+            url: buildFullUrl(baseOrigin, path),
+            group,
+            method: String(route.method ?? '').toUpperCase(),
+            path,
+            middleware: mw.middleware.join(', '),
+            validations: mw.validations.join(', '),
+            handler: normalizeHandlerName(route.handler),
+        };
+    });
+    const filtered = rows.filter((r) => {
+        if (methodFilter?.has(r.method) === false)
+            return false;
+        if (filterText === '')
+            return true;
+        const haystack = `${r.url} ${r.group} ${r.method} ${r.path} ${r.middleware} ${r.validations} ${r.handler}`
+            .toLowerCase()
+            .trim();
+        return haystack.includes(filterText);
+    });
+    // Keep stable ordering
+    filtered.sort((a, b) => {
+        if (a.group !== b.group)
+            return a.group.localeCompare(b.group);
+        if (a.path !== b.path)
+            return a.path.localeCompare(b.path);
+        return a.method.localeCompare(b.method);
+    });
+    return filtered;
+};
+const addOptions = (command) => {
+    command
+        .option('--group-by <mode>', 'group | service | none', 'group')
+        .option('--filter <text>', 'Filter by substring (path/middleware/handler/etc)')
+        .option('--method <methods>', 'Comma list of methods to include (e.g. GET,POST)')
+        .option('--json', 'Output machine-readable JSON instead of a table');
+};
+const execute = async (cmd, options) => {
+    const rows = await buildRows(options);
+    if (options.json === true) {
+        /* eslint-disable no-console */
+        console.log(JSON.stringify({ count: rows.length, routes: rows }, null, 2));
+        /* eslint-enable no-console */
+        return;
+    }
+    cmd.info(`Found ${rows.length} routes`);
+    renderTable(rows);
+};
+export const RoutesCommand = Object.freeze({
+    create() {
+        const cmd = BaseCommand.create({
+            name: 'routes',
+            aliases: ['route:list'],
+            description: 'List all routes (grouped by router group or service) with middleware and handler info',
+            addOptions,
+            execute: (options) => execute(cmd, options),
+        });
+        return cmd;
+    },
+});
+export default RoutesCommand;

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

@@ -0,0 +1,16 @@
+/**
+ * Secrets Command
+ *
+ * CLI-first secrets sync using the core internal toolkit.
+ *
+ * Usage:
+ *   zin secrets pull   --provider aws|cloudflare [--manifest secrets.manifest.json] [--out .env.pull] [--dry-run]
+ *   zin secrets push   --provider aws|cloudflare [--manifest secrets.manifest.json] [--in .env] [--dry-run]
+ *   zin secrets doctor --provider aws|cloudflare
+ */
+import { type IBaseCommand } from '../BaseCommand';
+export declare const SecretsCommand: Readonly<{
+    create(): IBaseCommand;
+}>;
+export default SecretsCommand;
+//# sourceMappingURL=SecretsCommand.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SecretsCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/SecretsCommand.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAoC,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAsHvF,eAAO,MAAM,cAAc;cACf,YAAY;EAWtB,CAAC;AAEH,eAAe,cAAc,CAAC"}

package/src/cli/commands/SecretsCommand.js

@@ -0,0 +1,91 @@
+/**
+ * Secrets Command
+ *
+ * CLI-first secrets sync using the core internal toolkit.
+ *
+ * Usage:
+ *   zin secrets pull   --provider aws|cloudflare [--manifest secrets.manifest.json] [--out .env.pull] [--dry-run]
+ *   zin secrets push   --provider aws|cloudflare [--manifest secrets.manifest.json] [--in .env] [--dry-run]
+ *   zin secrets doctor --provider aws|cloudflare
+ */
+import { BaseCommand } from '../BaseCommand.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { SecretsToolkit } from '../../toolkit/Secrets/index.js';
+const isUnknownArray = (value) => Array.isArray(value);
+const getArg = (args, index) => {
+    if (!isUnknownArray(args))
+        return undefined;
+    const v = args[index];
+    return typeof v === 'string' ? v : undefined;
+};
+const coerceProvider = (provider) => provider === 'aws' || provider === 'cloudflare' ? provider : undefined;
+const parseOptions = (options) => {
+    const cwd = process.cwd();
+    const action = getArg(options.args, 0) ?? 'pull';
+    const provider = typeof options.provider === 'string' ? coerceProvider(options.provider) : undefined;
+    const manifestPath = typeof options.manifest === 'string' ? options.manifest : undefined;
+    const outFile = typeof options.out === 'string' ? options.out : undefined;
+    const inFile = typeof options.in === 'string' ? options.in : undefined;
+    const dryRun = options.dryRun === true;
+    return { cwd, action, provider, manifestPath, outFile, inFile, dryRun };
+};
+const addOptions = (command) => {
+    command
+        .argument('[action]', 'pull | push | doctor', 'pull')
+        .option('--provider <provider>', 'aws | cloudflare')
+        .option('--manifest <path>', 'Manifest path (default: secrets.manifest.json)', 'secrets.manifest.json')
+        .option('--out <path>', 'Output env file for pull (default: .env.pull)', '.env.pull')
+        .option('--in <path>', 'Input env file for push (default: .env)', '.env')
+        .option('--dry-run', 'Do not write/upload, just show what would change');
+};
+const execute = async (cmd, options) => {
+    const parsed = parseOptions(options);
+    switch (parsed.action) {
+        case 'pull': {
+            const result = await SecretsToolkit.pull({
+                cwd: parsed.cwd,
+                provider: parsed.provider,
+                manifestPath: parsed.manifestPath,
+                outFile: parsed.outFile,
+                dryRun: parsed.dryRun,
+            });
+            cmd.success(`Pulled ${result.keys.length} keys to ${result.outFile}${parsed.dryRun ? ' (dry-run)' : ''}`);
+            return;
+        }
+        case 'push': {
+            const result = await SecretsToolkit.push({
+                cwd: parsed.cwd,
+                provider: parsed.provider,
+                manifestPath: parsed.manifestPath,
+                inFile: parsed.inFile,
+                dryRun: parsed.dryRun,
+            });
+            cmd.success(`Pushed ${result.keys.length} keys from ${result.inFile}${parsed.dryRun ? ' (dry-run)' : ''}`);
+            return;
+        }
+        case 'doctor': {
+            const result = SecretsToolkit.doctor({ provider: parsed.provider });
+            if (result.ok) {
+                cmd.success(`Secrets doctor OK (${result.provider})`);
+            }
+            else {
+                cmd.warn(`Secrets doctor failed (${result.provider}). Missing: ${result.missing.join(', ')}`);
+            }
+            return;
+        }
+        default:
+            throw ErrorFactory.createCliError(`Unknown secrets action: ${parsed.action}`);
+    }
+};
+export const SecretsCommand = Object.freeze({
+    create() {
+        const cmd = BaseCommand.create({
+            name: 'secrets',
+            description: 'Pull/push secrets to local .env.pull via core toolkit',
+            addOptions,
+            execute: async (options) => execute(cmd, options),
+        });
+        return cmd;
+    },
+});
+export default SecretsCommand;

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

@@ -0,0 +1,12 @@
+/**
+ * Simulate Command
+ * Internal dev tool that generates a simulated ZinTrust app under ./simulate/
+ * IMPORTANT: this uses the same ProjectScaffolder as `zin new`.
+ * Usage: zin -sim my-blog
+ */
+import type { IBaseCommand } from '../BaseCommand';
+/**
+ * SimulateCommand - Generate simulated apps for testing
+ */
+export declare const SimulateCommand: IBaseCommand;
+//# sourceMappingURL=SimulateCommand.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SimulateCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/SimulateCommand.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA+BrD;;GAEG;AACH,eAAO,MAAM,eAAe,EAuDvB,YAAY,CAAC"}