@zintrust/core 0.1.41 → 0.1.43

package/src/cli/commands/PutCommand.js

@@ -0,0 +1,173 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { resolveNpmPath } 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 { existsSync, readFileSync } from '../../node-singletons/fs.js';
+import * as path from '../../node-singletons/path.js';
+import { EnvFile } from '../../toolkit/Secrets/EnvFile.js';
+const toStringArray = (value) => {
+    if (typeof value === 'string')
+        return [value];
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((v) => typeof v === 'string');
+};
+const uniq = (items) => {
+    const seen = new Set();
+    const out = [];
+    for (const item of items) {
+        const normalized = item.trim();
+        if (normalized === '' || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        out.push(normalized);
+    }
+    return out;
+};
+const readZintrustConfig = (cwd) => {
+    const filePath = path.join(cwd, '.zintrust.json');
+    if (!existsSync(filePath)) {
+        return {};
+    }
+    try {
+        const raw = readFileSync(filePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'object' && parsed !== null ? parsed : {};
+    }
+    catch (error) {
+        throw ErrorFactory.createCliError('Failed to parse .zintrust.json', error);
+    }
+};
+const getConfigArray = (config, key) => {
+    const raw = config[key];
+    if (!Array.isArray(raw))
+        return [];
+    return uniq(raw.filter((item) => typeof item === 'string'));
+};
+const resolveConfigGroups = (options) => {
+    return uniq(toStringArray(options.var));
+};
+const resolveWranglerEnvs = (options) => {
+    const requested = uniq(toStringArray(options.wg));
+    if (requested.length === 0)
+        return ['worker'];
+    return requested;
+};
+const parseEnvPath = (options) => {
+    const direct = options['env_path'];
+    if (typeof direct === 'string' && direct.trim() !== '')
+        return direct;
+    return '.env';
+};
+const resolveValue = (key, envMap) => {
+    const fromFile = envMap[key];
+    const fromProcess = process.env[key];
+    return fromFile ?? fromProcess ?? '';
+};
+const getPutTimeoutMs = () => {
+    const raw = process.env['ZT_PUT_TIMEOUT_MS'];
+    if (typeof raw !== 'string')
+        return 120000;
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return 120000;
+    return parsed;
+};
+const putSecret = (wranglerEnv, key, value) => {
+    const npmPath = resolveNpmPath();
+    execFileSync(npmPath, ['exec', '--yes', '--', 'wrangler', 'secret', 'put', key, '--env', wranglerEnv], {
+        stdio: ['pipe', 'inherit', 'inherit'],
+        input: value,
+        encoding: 'utf8',
+        timeout: getPutTimeoutMs(),
+        killSignal: 'SIGTERM',
+        env: appConfig.getSafeEnv(),
+    });
+};
+const addOptions = (command) => {
+    command
+        .argument('[provider]', 'Secret provider (cloudflare)', 'cloudflare')
+        .option('--wg <env...>', 'Wrangler environment target(s), e.g. d1-proxy kv-proxy')
+        .option('--var <configKey...>', 'Config array key(s) from .zintrust.json (e.g. d1_env kv_env)')
+        .option('--env_path <path>', 'Path to env file used as source values', '.env')
+        .option('--dry-run', 'Show what would be uploaded without calling wrangler');
+};
+const ensureCloudflareProvider = (providerRaw) => {
+    if (providerRaw.toLowerCase() === 'cloudflare')
+        return;
+    throw ErrorFactory.createCliError('Only cloudflare provider is supported for `zin put`');
+};
+const resolveSelectedKeys = (cmd, config, options) => {
+    const configGroups = resolveConfigGroups(options);
+    if (configGroups.length === 0) {
+        throw ErrorFactory.createCliError('No config groups selected. Use --var <group>.');
+    }
+    const selectedKeys = uniq(configGroups.flatMap((groupKey) => {
+        const keys = getConfigArray(config, groupKey);
+        if (keys.length === 0) {
+            cmd.warn(`Group \`${groupKey}\` is missing or empty in .zintrust.json`);
+        }
+        return keys;
+    }));
+    if (selectedKeys.length === 0) {
+        throw ErrorFactory.createCliError('No secret keys resolved from selected groups.');
+    }
+    return selectedKeys;
+};
+const getFailureReason = (error) => error instanceof Error ? error.message : String(error);
+const reportResult = (cmd, pushed, failures) => {
+    cmd.success(`Cloudflare secrets report: pushed=${pushed}, failed=${failures.length}`);
+    for (const item of failures) {
+        cmd.warn(`${item.key} -> ${item.wranglerEnv}: ${item.reason}`);
+    }
+};
+const processPut = (cmd, wranglerEnvs, selectedKeys, envMap, dryRun) => {
+    let pushed = 0;
+    const failures = [];
+    for (const wranglerEnv of wranglerEnvs) {
+        for (const key of selectedKeys) {
+            const value = resolveValue(key, envMap);
+            if (value.trim() === '') {
+                failures.push({ wranglerEnv, key, reason: 'empty value' });
+                continue;
+            }
+            try {
+                if (!dryRun) {
+                    cmd.info(`putting ${key} -> ${wranglerEnv}...`);
+                    putSecret(wranglerEnv, key, value);
+                }
+                pushed += 1;
+                cmd.info(`${dryRun ? '[dry-run] ' : ''}put ${key} -> ${wranglerEnv}`);
+            }
+            catch (error) {
+                failures.push({ wranglerEnv, key, reason: getFailureReason(error) });
+            }
+        }
+    }
+    return { pushed, failures };
+};
+const execute = async (cmd, options) => {
+    ensureCloudflareProvider(String(options.args?.[0] ?? 'cloudflare'));
+    const cwd = process.cwd();
+    const config = readZintrustConfig(cwd);
+    const selectedKeys = resolveSelectedKeys(cmd, config, options);
+    const envFilePath = parseEnvPath(options);
+    const envMap = await EnvFile.read({ cwd, path: envFilePath });
+    const wranglerEnvs = resolveWranglerEnvs(options);
+    const dryRun = options.dryRun === true;
+    const result = processPut(cmd, wranglerEnvs, selectedKeys, envMap, dryRun);
+    reportResult(cmd, result.pushed, result.failures);
+};
+export const PutCommand = Object.freeze({
+    create() {
+        const cmd = BaseCommand.create({
+            name: 'put',
+            description: 'Put secrets to Cloudflare with dynamic groups from .zintrust.json',
+            addOptions,
+            execute: async (options) => execute(cmd, options),
+        });
+        return cmd;
+    },
+});
+export default PutCommand;

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

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

package/src/cli/commands/QueueRecoveryCommand.js

@@ -1,8 +1,10 @@
 import { BaseCommand } from '../BaseCommand.js';
+import { databaseConfig } from '../../config/database.js';
 import { Logger } from '../../config/logger.js';
 import { queueConfig } from '../../config/queue.js';
 import { ErrorFactory } from '../../exceptions/ZintrustError.js';
-import { useDatabase } from '../../orm/Database.js';
+import { resetDatabase, useDatabase } from '../../orm/Database.js';
+import { registerDatabasesFromRuntimeConfig } from '../../orm/DatabaseRuntimeRegistration.js';
 import { JobRecoveryDaemon } from '../../tools/queue/JobRecoveryDaemon.js';
 import { JobStateTracker } from '../../tools/queue/JobStateTracker.js';
 import { Queue } from '../../tools/queue/Queue.js';
@@ -57,6 +59,7 @@ const normalizeStatus = (value) => {
     const statuses = [
         'pending',
         'active',
+        'enqueued',
         'completed',
         'failed',
         'stalled',
@@ -98,17 +101,13 @@ const toRecordFromPersisted = (row) => {
     };
 };
 const getRecoverableStatuses = () => {
-    return new Set([
-        'pending_recovery',
-        'timeout',
-        'stalled',
-        'dead_letter',
-    ]);
+    return new Set(['pending_recovery']);
 };
 const getAllStatuses = () => {
     return new Set([
         'pending',
         'active',
+        'enqueued',
         'completed',
         'failed',
         'stalled',
@@ -355,8 +354,35 @@ const runRecoveryOnce = async () => {
     const result = await JobRecoveryDaemon.runOnce();
     Logger.info('Queue recovery run completed', result);
 };
+const isDuplicateJobIdError = (error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    const normalized = message.toLowerCase();
+    return normalized.includes('jobid') && normalized.includes('already exists');
+};
+const validatePushable = (record) => {
+    if (record.status === 'enqueued') {
+        Logger.info('Job is already enqueued; nothing to push', {
+            jobId: record.jobId,
+            queueName: record.queueName,
+        });
+        return { ok: false };
+    }
+    if (record.status !== 'pending_recovery') {
+        Logger.error(`Refusing to push job in status ${record.status}. Only pending_recovery can be pushed.`);
+        if (typeof process !== 'undefined')
+            process.exitCode = 1;
+        return { ok: false };
+    }
+    return { ok: true };
+};
 const runPushForJob = async (record, options) => {
-    const payload = toSafeObject(record.payload);
+    if (!validatePushable(record).ok)
+        return;
+    const basePayload = toSafeObject(record.payload);
+    const hasPayload = record.payload !== undefined &&
+        record.payload !== null &&
+        typeof record.payload === 'object' &&
+        Object.keys(basePayload).length > 0;
     if (options.dryRun) {
         Logger.info('Dry-run: skipping enqueue for target job', {
             jobId: record.jobId,
@@ -365,12 +391,36 @@ const runPushForJob = async (record, options) => {
         });
         return;
     }
-    const replayJobId = await Queue.enqueue(record.queueName, payload);
-    await JobStateTracker.markedRecovered({
+    if (!hasPayload) {
+        Logger.error(`Cannot push job because payload is missing in tracker/persistence store: ${record.jobId}. ` +
+            'Rehydrate payload_json first (or use policy recovery states) before pushing.');
+        if (typeof process !== 'undefined')
+            process.exitCode = 1;
+        return;
+    }
+    const payload = {
+        ...basePayload,
+        uniqueId: record.jobId,
+        attempts: typeof record.maxAttempts === 'number' ? record.maxAttempts : 3,
+        _currentAttempts: Math.max(0, Math.floor(record.attempts ?? 0)),
+        timestamp: Date.now(),
+    };
+    let replayJobId;
+    try {
+        replayJobId = await Queue.enqueue(record.queueName, payload, 'default');
+    }
+    catch (error) {
+        if (isDuplicateJobIdError(error)) {
+            replayJobId = record.jobId;
+        }
+        else {
+            throw error;
+        }
+    }
+    await JobStateTracker.handedOffToQueue({
         queueName: record.queueName,
         jobId: record.jobId,
         reason: `CLI pushed job as ${replayJobId}`,
-        retryAt: new Date().toISOString(),
     });
     Logger.info('Target job pushed to queue', {
         originalJobId: record.jobId,
@@ -378,6 +428,21 @@ const runPushForJob = async (record, options) => {
         queueName: record.queueName,
     });
 };
+const isTestRuntime = () => (process.env['NODE_ENV'] ?? '').trim().toLowerCase() === 'test' || Boolean(process.env['VITEST']);
+const cleanupOneOffCli = async () => {
+    try {
+        QueueReliabilityOrchestrator.stop();
+    }
+    catch {
+        // ignore
+    }
+    try {
+        await resetDatabase();
+    }
+    catch {
+        // ignore
+    }
+};
 const runRecoverOneForJob = async (record, options) => {
     if (options.dryRun) {
         Logger.info('Dry-run: skipping policy recovery for target job', {
@@ -456,10 +521,23 @@ const runTargetedRecovery = async (resolved) => {
         return;
     const record = await findRecord(resolved.jobId, resolved.queueName, resolved.allowDbLookup);
     if (record === null) {
-        throw ErrorFactory.createConfigError(`Job not found in tracker${resolved.allowDbLookup ? ' or persistence store' : ''}: ${resolved.jobId}`);
+        Logger.error(`Job not found in tracker${resolved.allowDbLookup ? ' or persistence store' : ''}: ${resolved.jobId}`);
+        if (typeof process !== 'undefined')
+            process.exitCode = 1;
+        return;
+    }
+    if (record.status === 'enqueued' && !resolved.push) {
+        Logger.info('Job already enqueued; nothing to recover', {
+            jobId: record.jobId,
+            queueName: record.queueName,
+        });
+        return;
     }
     if (!resolved.push && !getRecoverableStatuses().has(record.status)) {
-        throw ErrorFactory.createConfigError(`Job status is not recoverable via policy runner: ${record.status}. Use --push to force requeue.`);
+        Logger.error(`Job status is not recoverable via policy runner: ${record.status}. Use --push to force requeue.`);
+        if (typeof process !== 'undefined')
+            process.exitCode = 1;
+        return;
     }
     if (resolved.push) {
         await runPushForJob(record, { dryRun: resolved.dryRun });
@@ -480,11 +558,32 @@ const executeQueueRecovery = async (options) => {
     const resolved = resolveExecutionOptions(options);
     if (await maybeRunListMode(resolved))
         return;
-    await registerQueuesFromRuntimeConfig(queueConfig);
+    // Ensure DB connections exist for optional persistence lookups.
+    // (CLI commands don't run full app bootstrap.)
+    registerDatabasesFromRuntimeConfig(databaseConfig);
+    const envDefault = (process.env['QUEUE_DRIVER'] ?? '').toString().trim().toLowerCase();
+    const cliQueueConfig = {
+        ...queueConfig,
+        default: (envDefault.length > 0
+            ? envDefault
+            : queueConfig.default),
+    };
+    await registerQueuesFromRuntimeConfig(cliQueueConfig);
+    if (!resolved.start) {
+        // Queue registration may auto-start orchestrator when JOB_RELIABILITY_AUTOSTART=true.
+        // For one-off CLI runs, stop it to avoid noisy intervals.
+        QueueReliabilityOrchestrator.stop();
+    }
     if (await maybeRunDefaultRecovery(resolved))
         return;
     await runTargetedRecovery(resolved);
     await finalizeRecoveryExecution(resolved);
+    if (!resolved.start) {
+        await cleanupOneOffCli();
+        if (!isTestRuntime() && typeof process !== 'undefined') {
+            process.exit(process.exitCode ?? 0);
+        }
+    }
 };
 export const QueueRecoveryCommand = Object.freeze({
     create() {

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.map

@@ -1 +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"}
+{"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"}

package/src/cli/commands/SecretsCommand.js

@@ -10,10 +10,10 @@
  */
 import { BaseCommand } from '../BaseCommand.js';
 import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { isArray } from '../../helper/index.js';
 import { SecretsToolkit } from '../../toolkit/Secrets/index.js';
-const isUnknownArray = (value) => Array.isArray(value);
 const getArg = (args, index) => {
-    if (!isUnknownArray(args))
+    if (!isArray(args))
         return undefined;
     const v = args[index];
     return typeof v === 'string' ? v : undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"StartCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/StartCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoC,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAqkBvF,eAAO,MAAM,YAAY;cACb,YAAY;EA0BtB,CAAC"}
+{"version":3,"file":"StartCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/StartCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoC,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA2lBvF,eAAO,MAAM,YAAY;cACb,YAAY;EA4BtB,CAAC"}

package/src/cli/commands/StartCommand.js

@@ -132,6 +132,20 @@ const resolveWatchPreference = (options, mode) => {
         return options.watch;
     return mode === 'development';
 };
+const resolveCacheEnabledPreference = (options) => {
+    const hasCache = hasFlag('--cache');
+    const hasNoCache = hasFlag('--no-cache');
+    if (hasCache && hasNoCache) {
+        throw ErrorFactory.createCliError('Error: Cannot use both --cache and --no-cache.');
+    }
+    if (hasCache)
+        return true;
+    if (hasNoCache)
+        return false;
+    if (typeof options.cache === 'boolean')
+        return options.cache;
+    return undefined;
+};
 const readPackageJson = (cwd) => {
     const packagePath = path.join(cwd, 'package.json');
     if (!existsSync(packagePath)) {
@@ -407,7 +421,13 @@ const executeStart = async (options, cmd) => {
         await executeSplitStart(cmd, cwd, options);
         return;
     }
-    EnvFileLoader.applyCliOverrides({ nodeEnv: mode, port, runtime: effectiveRuntime });
+    const cacheEnabled = resolveCacheEnabledPreference(options);
+    EnvFileLoader.applyCliOverrides({
+        nodeEnv: mode,
+        port,
+        runtime: effectiveRuntime,
+        ...(typeof cacheEnabled === 'boolean' ? { cacheEnabled } : {}),
+    });
     if (variant === 'wrangler') {
         await executeWranglerStart(cmd, cwd, port, runtime, envName === '' ? undefined : envName);
         return;
@@ -435,6 +455,8 @@ export const StartCommand = Object.freeze({
                 .option('--wg', 'Alias for --wrangler')
                 .option('--deno', 'Start a local server using the Deno runtime adapter')
                 .option('--lambda', 'Start a local server using the AWS Lambda runtime adapter')
+                .option('--cache', 'Enable cache functionality')
+                .option('--no-cache', 'Disable cache functionality')
                 .option('--watch', 'Force watch mode (Node only)')
                 .option('--no-watch', 'Disable watch mode (Node only)')
                 .option('--mode <development|production|testing>', 'Override app mode')

package/src/cli/commands/schedule/ScheduleCliSupport.d.ts

@@ -0,0 +1,6 @@
+export declare const ScheduleCliSupport: Readonly<{
+    registerAll(): Promise<void>;
+    shutdownCliResources: () => Promise<void>;
+}>;
+export default ScheduleCliSupport;
+//# sourceMappingURL=ScheduleCliSupport.d.ts.map

package/src/cli/commands/schedule/ScheduleCliSupport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduleCliSupport.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/schedule/ScheduleCliSupport.ts"],"names":[],"mappings":"AAwDA,eAAO,MAAM,kBAAkB;mBACR,OAAO,CAAC,IAAI,CAAC;gCA1BG,OAAO,CAAC,IAAI,CAAC;EAmClD,CAAC;AAEH,eAAe,kBAAkB,CAAC"}