@zintrust/core 0.4.17 → 0.4.18

package/src/cli/commands/RedisProxyCommand.js

@@ -0,0 +1,53 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { maybeRunProxyWatchMode, parseIntOption, trimOption, } from '../commands/ProxyCommandUtils.js';
+import { Env } from '../../config/env.js';
+import { RedisProxyServer } from '../../proxy/redis/RedisProxyServer.js';
+const addOptions = (command) => {
+    command.option('--host <host>', 'Host to bind', Env.get('REDIS_PROXY_HOST', '127.0.0.1'));
+    command.option('--port <port>', 'Port to bind', String(Env.getInt('REDIS_PROXY_PORT', 8791)));
+    command.option('--max-body-bytes <bytes>', 'Max request size in bytes', String(Env.getInt('REDIS_PROXY_MAX_BODY_BYTES', 131072)));
+    command.option('--watch', 'Auto-restart proxy on file changes');
+    command.option('--redis-host <host>', 'Redis host');
+    command.option('--redis-port <port>', 'Redis port');
+    command.option('--redis-password <password>', 'Redis password');
+    command.option('--redis-db <db>', 'Redis database');
+    command.option('--require-signing', 'Require signed requests', Env.REDIS_PROXY_REQUIRE_SIGNING);
+    command.option('--key-id <id>', 'Signing key id', Env.get('REDIS_PROXY_KEY_ID', ''));
+    command.option('--secret <secret>', 'Signing secret', Env.get('REDIS_PROXY_SECRET', ''));
+    command.option('--signing-window-ms <ms>', 'Signing time window in ms', String(Env.getInt('REDIS_PROXY_SIGNING_WINDOW_MS', 60000)));
+};
+export const RedisProxyCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'proxy:redis',
+            aliases: ['redis:proxy', 'redis-proxy', 'proxy:red'],
+            description: 'Start the Redis HTTP proxy for Cloudflare Workers',
+            addOptions,
+            execute: async (options) => {
+                await maybeRunProxyWatchMode(options.watch);
+                const host = trimOption(options.host);
+                const port = parseIntOption(options.port, 'port');
+                const maxBodyBytes = parseIntOption(options.maxBodyBytes, 'max-body-bytes');
+                const redisHost = trimOption(options.redisHost);
+                const redisPort = parseIntOption(options.redisPort, 'redis-port', 'non-negative');
+                const redisPassword = options.redisPassword;
+                const redisDb = parseIntOption(options.redisDb, 'redis-db', 'non-negative');
+                const signingWindowMs = parseIntOption(options.signingWindowMs, 'signing-window-ms');
+                await RedisProxyServer.start({
+                    host,
+                    port,
+                    maxBodyBytes,
+                    redisHost,
+                    redisPort,
+                    redisPassword,
+                    redisDb,
+                    requireSigning: options.requireSigning === true,
+                    keyId: options.keyId,
+                    secret: options.secret,
+                    signingWindowMs,
+                });
+            },
+        });
+    },
+});
+export default RedisProxyCommand;

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;AA2VvF,eAAO,MAAM,aAAa;cACd,YAAY;EAatB,CAAC;AAEH,eAAe,aAAa,CAAC"}

package/src/cli/commands/RoutesCommand.js

@@ -0,0 +1,290 @@
+/**
+ * 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';
+import { isObject } from '../../helper/index.js';
+import { getServicePrefix } from '../../microservices/ServiceManifest.js';
+import { ProjectRuntime } from '../../runtime/ProjectRuntime.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 annotateManifestRoutes = (router, beforeCount, serviceId) => {
+    const routes = Router.getRoutes(router);
+    for (const route of routes.slice(beforeCount)) {
+        route.__zintrustServiceId = serviceId;
+    }
+};
+const getRouteServiceId = (route) => {
+    return route.__zintrustServiceId ?? '';
+};
+const registerManifestRoutes = async (router) => {
+    await ProjectRuntime.tryLoadNodeRuntime();
+    const serviceManifest = ProjectRuntime.getServiceManifest();
+    if (serviceManifest.length === 0)
+        return;
+    for (const entry of serviceManifest) {
+        if (entry.monolithEnabled === false || typeof entry.loadRoutes !== 'function')
+            continue;
+        try {
+            const beforeCount = Router.getRoutes(router).length;
+            // eslint-disable-next-line no-await-in-loop
+            const mod = await entry.loadRoutes();
+            const registerRoutes = isObject(mod) ? mod.registerRoutes : undefined;
+            if (typeof registerRoutes === 'function') {
+                Router.group(router, getServicePrefix(entry), (scopedRouter) => {
+                    registerRoutes(scopedRouter);
+                });
+                annotateManifestRoutes(router, beforeCount, entry.id);
+            }
+        }
+        catch {
+            // Ignore broken optional service routes and keep listing what is available.
+        }
+    }
+};
+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
+    }
+    await registerManifestRoutes(router);
+    const routes = Router.getRoutes(router);
+    const rows = routes.map((route) => {
+        const path = normalizePath(route.path);
+        const serviceId = getRouteServiceId(route);
+        let group = '';
+        if (groupBy === 'service') {
+            group = serviceId === '' ? deriveService(path) : serviceId;
+        }
+        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/ScheduleListCommand.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduleListCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/ScheduleListCommand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAsErE,eAAO,MAAM,mBAAmB;cACpB,YAAY;EAUtB,CAAC;AAEH,eAAe,mBAAmB,CAAC"}

package/src/cli/commands/ScheduleListCommand.js

@@ -0,0 +1,62 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { ScheduleCliSupport } from '../commands/schedule/ScheduleCliSupport.js';
+import { Logger } from '../../config/logger.js';
+import { SchedulerRuntime } from '../../scheduler/SchedulerRuntime.js';
+const execute = async (options) => {
+    try {
+        await ScheduleCliSupport.registerAll();
+        const toIso = (ms) => typeof ms === 'number' && Number.isFinite(ms) ? new Date(ms).toISOString() : undefined;
+        const rows = (await SchedulerRuntime.listWithState())
+            .map(({ schedule: s, state }) => ({
+            name: s.name,
+            enabled: s.enabled !== false,
+            intervalMs: s.intervalMs,
+            cron: s.cron,
+            timezone: s.timezone,
+            runOnStart: s.runOnStart === true,
+            consecutiveFailures: state?.consecutiveFailures,
+            lastRunAt: toIso(state?.lastRunAt),
+            lastSuccessAt: toIso(state?.lastSuccessAt),
+            lastErrorAt: toIso(state?.lastErrorAt),
+            lastErrorMessage: state?.lastErrorMessage,
+            nextRunAt: toIso(state?.nextRunAt),
+        }))
+            .sort((a, b) => a.name.localeCompare(b.name));
+        if (options.json === true) {
+            Logger.info(JSON.stringify(rows, null, 2));
+            return;
+        }
+        if (rows.length === 0) {
+            Logger.info('No schedules registered');
+            return;
+        }
+        rows.forEach((row) => {
+            const hasText = (value) => typeof value === 'string' && value.trim().length > 0;
+            const tzSuffix = hasText(row.timezone) ? ` tz=${row.timezone}` : '';
+            const cadence = typeof row.cron === 'string' && row.cron.trim().length > 0
+                ? `cron=${row.cron}${tzSuffix}`
+                : `intervalMs=${row.intervalMs ?? 'manual'}`;
+            const hasStateInfo = [row.nextRunAt, row.lastSuccessAt, row.lastErrorAt].some(hasText);
+            const extra = hasStateInfo
+                ? ` next=${row.nextRunAt ?? '-'} lastOk=${row.lastSuccessAt ?? '-'} lastErr=${row.lastErrorAt ?? '-'}`
+                : '';
+            Logger.info(`${row.name} (enabled=${row.enabled}, ${cadence}, runOnStart=${row.runOnStart}, failures=${row.consecutiveFailures ?? 0})${extra}`);
+        });
+    }
+    finally {
+        await ScheduleCliSupport.shutdownCliResources();
+    }
+};
+export const ScheduleListCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'schedule:list',
+            description: 'List all registered schedules',
+            addOptions: (command) => {
+                command.option('--json', 'Output JSON');
+            },
+            execute,
+        });
+    },
+});
+export default ScheduleListCommand;

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

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

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

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

package/src/cli/commands/ScheduleRunCommand.js

@@ -0,0 +1,32 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { ScheduleCliSupport } from '../commands/schedule/ScheduleCliSupport.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { SchedulerRuntime } from '../../scheduler/SchedulerRuntime.js';
+const execute = async (options) => {
+    const name = (options.name ?? '').trim();
+    if (name.length === 0)
+        throw ErrorFactory.createConfigError('--name is required');
+    try {
+        await ScheduleCliSupport.registerAll();
+        Logger.info('Running schedule once', { name });
+        await SchedulerRuntime.runOnce(name);
+        Logger.info('Schedule run completed', { name });
+    }
+    finally {
+        await ScheduleCliSupport.shutdownCliResources();
+    }
+};
+export const ScheduleRunCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'schedule:run',
+            description: 'Run a specific schedule once and exit',
+            addOptions: (command) => {
+                command.option('--name <name>', 'Schedule name to run');
+            },
+            execute,
+        });
+    },
+});
+export default ScheduleRunCommand;

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

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

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

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

package/src/cli/commands/ScheduleStartCommand.js

@@ -0,0 +1,40 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { ScheduleCliSupport } from '../commands/schedule/ScheduleCliSupport.js';
+import { Env } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { SchedulerRuntime } from '../../scheduler/SchedulerRuntime.js';
+const waitForSignal = async () => {
+    if (typeof process === 'undefined' || typeof process.once !== 'function') {
+        throw ErrorFactory.createGeneralError('schedule:start is only supported in Node.js runtimes');
+    }
+    return new Promise((resolve) => {
+        process.once('SIGTERM', () => resolve('SIGTERM'));
+        process.once('SIGINT', () => resolve('SIGINT'));
+    });
+};
+const execute = async (_options) => {
+    if (Env.getBool('SCHEDULES_ENABLED', false) === false) {
+        Logger.info('Schedules are disabled (SCHEDULES_ENABLED=false); exiting');
+        return;
+    }
+    await ScheduleCliSupport.registerAll();
+    const registeredCount = SchedulerRuntime.list().length;
+    Logger.info('Starting schedules daemon', { registeredCount });
+    SchedulerRuntime.start();
+    const signal = await waitForSignal();
+    Logger.info('Stopping schedules daemon', { signal });
+    const timeoutMs = Env.getInt('SCHEDULE_SHUTDOWN_TIMEOUT_MS', 30000);
+    await SchedulerRuntime.stop(timeoutMs);
+    Logger.info('Schedules daemon stopped');
+};
+export const ScheduleStartCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'schedule:start',
+            description: 'Start schedules and keep running until SIGINT/SIGTERM',
+            execute,
+        });
+    },
+});
+export default ScheduleStartCommand;

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;AAqHvF,eAAO,MAAM,cAAc;cACf,YAAY;EAWtB,CAAC;AAEH,eAAe,cAAc,CAAC"}