opc-agent 3.0.1 → 4.0.1

package/dist/scheduler/cron-engine.js

@@ -0,0 +1,200 @@
+"use strict";
+/**
+ * Cron Engine — persistent scheduler with file-based storage.
+ * Manages scheduled tasks with cron expressions, persists to ~/.opc/schedules.json,
+ * and auto-recovers on startup.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronEngine = void 0;
+exports.frequencyToCron = frequencyToCron;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os = __importStar(require("os"));
+const scheduler_1 = require("../core/scheduler");
+function getSchedulesPath() {
+    const dir = (0, path_1.join)(os.homedir(), '.opc');
+    if (!(0, fs_1.existsSync)(dir))
+        (0, fs_1.mkdirSync)(dir, { recursive: true });
+    return (0, path_1.join)(dir, 'schedules.json');
+}
+function loadSchedules() {
+    const p = getSchedulesPath();
+    if ((0, fs_1.existsSync)(p)) {
+        try {
+            return JSON.parse((0, fs_1.readFileSync)(p, 'utf-8'));
+        }
+        catch { /* ignore */ }
+    }
+    return { tasks: [] };
+}
+function saveSchedules(store) {
+    (0, fs_1.writeFileSync)(getSchedulesPath(), JSON.stringify(store, null, 2));
+}
+/** Convert frequency + time to cron expression */
+function frequencyToCron(frequency, time) {
+    const [hour, minute] = (time || '09:00').split(':').map(Number);
+    switch (frequency) {
+        case 'daily': return `${minute} ${hour} * * *`;
+        case 'weekly': return `${minute} ${hour} * * 1`;
+        case 'monthly': return `${minute} ${hour} 1 * *`;
+        default: return '0 9 * * *'; // fallback
+    }
+}
+/** Compute next run from a cron expression */
+function computeNextRun(cronExpr) {
+    try {
+        const parsed = (0, scheduler_1.parseCron)(cronExpr);
+        const d = new Date();
+        d.setSeconds(0, 0);
+        d.setMinutes(d.getMinutes() + 1);
+        for (let i = 0; i < 48 * 60; i++) {
+            if ((0, scheduler_1.cronMatches)(parsed, d))
+                return d.toISOString();
+            d.setMinutes(d.getMinutes() + 1);
+        }
+    }
+    catch { /* ignore */ }
+    return undefined;
+}
+class CronEngine {
+    scheduler;
+    store;
+    handler;
+    constructor(handler) {
+        this.handler = handler || (async (job) => {
+            console.log(`[cron-engine] Executing job: ${job.name} (${job.id})`);
+        });
+        this.scheduler = new scheduler_1.Scheduler(this.handler);
+        this.store = loadSchedules();
+    }
+    /** Initialize and recover persisted tasks */
+    start() {
+        for (const task of this.store.tasks) {
+            if (task.enabled) {
+                this.scheduler.addJob({
+                    id: task.id,
+                    name: task.name,
+                    schedule: task.schedule,
+                    task: task.description,
+                    enabled: true,
+                });
+            }
+        }
+        this.scheduler.start();
+        console.log(`[cron-engine] Started with ${this.store.tasks.filter(t => t.enabled).length} active tasks`);
+    }
+    stop() {
+        this.scheduler.stop();
+    }
+    listTasks() {
+        // Refresh nextRun
+        return this.store.tasks.map(t => ({
+            ...t,
+            nextRun: t.enabled ? computeNextRun(t.schedule) : undefined,
+        }));
+    }
+    getTask(id) {
+        return this.store.tasks.find(t => t.id === id);
+    }
+    createTask(input) {
+        const id = `sched-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+        const now = new Date().toISOString();
+        const schedule = input.schedule || frequencyToCron(input.frequency, input.time);
+        const task = {
+            ...input,
+            id,
+            schedule,
+            createdAt: now,
+            updatedAt: now,
+            nextRun: input.enabled ? computeNextRun(schedule) : undefined,
+        };
+        this.store.tasks.push(task);
+        saveSchedules(this.store);
+        if (task.enabled) {
+            this.scheduler.addJob({
+                id: task.id,
+                name: task.name,
+                schedule: task.schedule,
+                task: task.description,
+                enabled: true,
+            });
+        }
+        return task;
+    }
+    updateTask(id, updates) {
+        const idx = this.store.tasks.findIndex(t => t.id === id);
+        if (idx === -1)
+            return null;
+        const task = { ...this.store.tasks[idx], ...updates, id, updatedAt: new Date().toISOString() };
+        if (updates.frequency || updates.time) {
+            task.schedule = updates.schedule || frequencyToCron(task.frequency, task.time);
+        }
+        task.nextRun = task.enabled ? computeNextRun(task.schedule) : undefined;
+        this.store.tasks[idx] = task;
+        saveSchedules(this.store);
+        // Update scheduler
+        this.scheduler.removeJob(id);
+        if (task.enabled) {
+            this.scheduler.addJob({
+                id: task.id,
+                name: task.name,
+                schedule: task.schedule,
+                task: task.description,
+                enabled: true,
+            });
+        }
+        return task;
+    }
+    deleteTask(id) {
+        const idx = this.store.tasks.findIndex(t => t.id === id);
+        if (idx === -1)
+            return false;
+        this.store.tasks.splice(idx, 1);
+        saveSchedules(this.store);
+        this.scheduler.removeJob(id);
+        return true;
+    }
+    async runTask(id) {
+        const task = this.store.tasks.find(t => t.id === id);
+        if (!task)
+            return false;
+        task.lastRun = new Date().toISOString();
+        saveSchedules(this.store);
+        return this.scheduler.runJob(id);
+    }
+}
+exports.CronEngine = CronEngine;
+//# sourceMappingURL=cron-engine.js.map

package/dist/scheduler/index.d.ts

@@ -0,0 +1,3 @@
+export { CronEngine, frequencyToCron } from './cron-engine';
+export type { ScheduleTask, SchedulesStore } from './cron-engine';
+//# sourceMappingURL=index.d.ts.map

package/dist/scheduler/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.frequencyToCron = exports.CronEngine = void 0;
+var cron_engine_1 = require("./cron-engine");
+Object.defineProperty(exports, "CronEngine", { enumerable: true, get: function () { return cron_engine_1.CronEngine; } });
+Object.defineProperty(exports, "frequencyToCron", { enumerable: true, get: function () { return cron_engine_1.frequencyToCron; } });
+//# sourceMappingURL=index.js.map

package/dist/schema/oad.d.ts

@@ -39,14 +39,14 @@ export declare const VoiceSchema: z.ZodObject<{
     language: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     enabled: boolean;
+    language?: string | undefined;
     sttProvider?: string | undefined;
     ttsProvider?: string | undefined;
-    language?: string | undefined;
 }, {
+    language?: string | undefined;
     enabled?: boolean | undefined;
     sttProvider?: string | undefined;
     ttsProvider?: string | undefined;
-    language?: string | undefined;
 }>;
 export declare const WebhookSchema: z.ZodObject<{
     path: z.ZodOptional<z.ZodString>;
@@ -827,14 +827,14 @@ export declare const SpecSchema: z.ZodObject<{
         language: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         enabled: boolean;
+        language?: string | undefined;
         sttProvider?: string | undefined;
         ttsProvider?: string | undefined;
-        language?: string | undefined;
     }, {
+        language?: string | undefined;
         enabled?: boolean | undefined;
         sttProvider?: string | undefined;
         ttsProvider?: string | undefined;
-        language?: string | undefined;
     }>>;
     webhook: z.ZodOptional<z.ZodObject<{
         path: z.ZodOptional<z.ZodString>;
@@ -1071,9 +1071,9 @@ export declare const SpecSchema: z.ZodObject<{
     } | undefined;
     voice?: {
         enabled: boolean;
+        language?: string | undefined;
         sttProvider?: string | undefined;
         ttsProvider?: string | undefined;
-        language?: string | undefined;
     } | undefined;
     webhook?: {
         path?: string | undefined;
@@ -1185,10 +1185,10 @@ export declare const SpecSchema: z.ZodObject<{
         sessionIsolation?: boolean | undefined;
     } | undefined;
     voice?: {
+        language?: string | undefined;
         enabled?: boolean | undefined;
         sttProvider?: string | undefined;
         ttsProvider?: string | undefined;
-        language?: string | undefined;
     } | undefined;
     webhook?: {
         path?: string | undefined;
@@ -1573,14 +1573,14 @@ export declare const OADSchema: z.ZodObject<{
             language: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             enabled: boolean;
+            language?: string | undefined;
             sttProvider?: string | undefined;
             ttsProvider?: string | undefined;
-            language?: string | undefined;
         }, {
+            language?: string | undefined;
             enabled?: boolean | undefined;
             sttProvider?: string | undefined;
             ttsProvider?: string | undefined;
-            language?: string | undefined;
         }>>;
         webhook: z.ZodOptional<z.ZodObject<{
             path: z.ZodOptional<z.ZodString>;
@@ -1817,9 +1817,9 @@ export declare const OADSchema: z.ZodObject<{
         } | undefined;
         voice?: {
             enabled: boolean;
+            language?: string | undefined;
             sttProvider?: string | undefined;
             ttsProvider?: string | undefined;
-            language?: string | undefined;
         } | undefined;
         webhook?: {
             path?: string | undefined;
@@ -1931,10 +1931,10 @@ export declare const OADSchema: z.ZodObject<{
             sessionIsolation?: boolean | undefined;
         } | undefined;
         voice?: {
+            language?: string | undefined;
             enabled?: boolean | undefined;
             sttProvider?: string | undefined;
             ttsProvider?: string | undefined;
-            language?: string | undefined;
         } | undefined;
         webhook?: {
             path?: string | undefined;
@@ -2092,9 +2092,9 @@ export declare const OADSchema: z.ZodObject<{
         } | undefined;
         voice?: {
             enabled: boolean;
+            language?: string | undefined;
             sttProvider?: string | undefined;
             ttsProvider?: string | undefined;
-            language?: string | undefined;
         } | undefined;
         webhook?: {
             path?: string | undefined;
@@ -2223,10 +2223,10 @@ export declare const OADSchema: z.ZodObject<{
             sessionIsolation?: boolean | undefined;
         } | undefined;
         voice?: {
+            language?: string | undefined;
             enabled?: boolean | undefined;
             sttProvider?: string | undefined;
             ttsProvider?: string | undefined;
-            language?: string | undefined;
         } | undefined;
         webhook?: {
             path?: string | undefined;

package/dist/security/approvals.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Approvals Module - v1.0.0
+ * Policy-based exec approval system with queue, expiry, history, and callbacks.
+ */
+export type ExecApprovalPolicy = 'always' | 'elevated-only' | 'never' | 'allowlist';
+export interface ExecApprovalRequest {
+    id: string;
+    command: string;
+    elevated: boolean;
+    requestedAt: number;
+    expiresAt: number;
+    status: 'pending' | 'approved' | 'denied' | 'expired';
+    approvedBy?: string;
+    reason?: string;
+}
+export interface ExecApprovalHistory {
+    request: ExecApprovalRequest;
+    resolvedAt: number;
+}
+export type ApprovalRequestCallback = (request: ExecApprovalRequest) => void;
+export declare class ExecApprovalManager {
+    private policy;
+    private pending;
+    private history;
+    private allowedCommands;
+    private expiryMs;
+    private onRequestCallback?;
+    private expiryTimer?;
+    constructor(options?: {
+        policy?: ExecApprovalPolicy;
+        expiryMs?: number;
+        allowedCommands?: string[];
+        onRequest?: ApprovalRequestCallback;
+    });
+    getPolicy(): ExecApprovalPolicy;
+    setPolicy(p: ExecApprovalPolicy): void;
+    addAllowedCommand(cmd: string): void;
+    removeAllowedCommand(cmd: string): void;
+    getAllowedCommands(): string[];
+    needsApproval(command: string, elevated: boolean): boolean;
+    private isAllowed;
+    request(command: string, elevated?: boolean): ExecApprovalRequest;
+    approve(id: string, approver: string): ExecApprovalRequest;
+    deny(id: string, approver: string, reason?: string): ExecApprovalRequest;
+    getPending(): ExecApprovalRequest[];
+    getHistory(): ExecApprovalHistory[];
+    getRequest(id: string): ExecApprovalRequest | undefined;
+    private expirePending;
+    /** Force expire check (for testing) */
+    checkExpiry(): void;
+    destroy(): void;
+}
+//# sourceMappingURL=approvals.d.ts.map

package/dist/security/approvals.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * Approvals Module - v1.0.0
+ * Policy-based exec approval system with queue, expiry, history, and callbacks.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecApprovalManager = void 0;
+const crypto_1 = require("crypto");
+class ExecApprovalManager {
+    policy;
+    pending = new Map();
+    history = [];
+    allowedCommands = new Set();
+    expiryMs;
+    onRequestCallback;
+    expiryTimer;
+    constructor(options = {}) {
+        this.policy = options.policy ?? 'elevated-only';
+        this.expiryMs = options.expiryMs ?? 300_000; // 5 min default
+        this.onRequestCallback = options.onRequest;
+        if (options.allowedCommands) {
+            for (const cmd of options.allowedCommands)
+                this.allowedCommands.add(cmd);
+        }
+        this.expiryTimer = setInterval(() => this.expirePending(), 10_000);
+        if (this.expiryTimer.unref)
+            this.expiryTimer.unref();
+    }
+    getPolicy() { return this.policy; }
+    setPolicy(p) { this.policy = p; }
+    addAllowedCommand(cmd) { this.allowedCommands.add(cmd); }
+    removeAllowedCommand(cmd) { this.allowedCommands.delete(cmd); }
+    getAllowedCommands() { return [...this.allowedCommands]; }
+    needsApproval(command, elevated) {
+        switch (this.policy) {
+            case 'never': return false;
+            case 'always': return true;
+            case 'elevated-only': return elevated;
+            case 'allowlist': return !this.isAllowed(command);
+        }
+    }
+    isAllowed(command) {
+        for (const allowed of this.allowedCommands) {
+            if (command.startsWith(allowed) || command === allowed)
+                return true;
+        }
+        return false;
+    }
+    request(command, elevated = false) {
+        const now = Date.now();
+        const req = {
+            id: (0, crypto_1.randomUUID)(),
+            command,
+            elevated,
+            requestedAt: now,
+            expiresAt: now + this.expiryMs,
+            status: 'pending',
+        };
+        this.pending.set(req.id, req);
+        this.onRequestCallback?.(req);
+        return req;
+    }
+    approve(id, approver) {
+        const req = this.pending.get(id);
+        if (!req)
+            throw new Error(`Request ${id} not found`);
+        if (req.status !== 'pending')
+            throw new Error(`Request ${id} already ${req.status}`);
+        req.status = 'approved';
+        req.approvedBy = approver;
+        this.pending.delete(id);
+        this.history.push({ request: req, resolvedAt: Date.now() });
+        return req;
+    }
+    deny(id, approver, reason) {
+        const req = this.pending.get(id);
+        if (!req)
+            throw new Error(`Request ${id} not found`);
+        if (req.status !== 'pending')
+            throw new Error(`Request ${id} already ${req.status}`);
+        req.status = 'denied';
+        req.approvedBy = approver;
+        req.reason = reason;
+        this.pending.delete(id);
+        this.history.push({ request: req, resolvedAt: Date.now() });
+        return req;
+    }
+    getPending() {
+        return [...this.pending.values()];
+    }
+    getHistory() {
+        return [...this.history];
+    }
+    getRequest(id) {
+        return this.pending.get(id) ?? this.history.find(h => h.request.id === id)?.request;
+    }
+    expirePending() {
+        const now = Date.now();
+        for (const [id, req] of this.pending) {
+            if (now >= req.expiresAt) {
+                req.status = 'expired';
+                this.pending.delete(id);
+                this.history.push({ request: req, resolvedAt: now });
+            }
+        }
+    }
+    /** Force expire check (for testing) */
+    checkExpiry() { this.expirePending(); }
+    destroy() {
+        if (this.expiryTimer)
+            clearInterval(this.expiryTimer);
+    }
+}
+exports.ExecApprovalManager = ExecApprovalManager;
+//# sourceMappingURL=approvals.js.map

package/dist/security/elevated.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Elevated Permissions Module - v1.0.0
+ * Elevation mode management with allowed commands, auto-revoke, and audit log.
+ */
+export type ElevationMode = 'off' | 'ask' | 'on';
+export interface ElevationAuditEntry {
+    timestamp: number;
+    action: 'elevate' | 'revoke' | 'execute' | 'deny';
+    command?: string;
+    reason?: string;
+}
+export declare class ElevatedManager {
+    private mode;
+    private elevated;
+    private allowedCommands;
+    private auditLog;
+    private revokeTimer?;
+    private autoRevokeMs;
+    constructor(options?: {
+        mode?: ElevationMode;
+        allowedCommands?: (string | RegExp)[];
+        autoRevokeMs?: number;
+    });
+    getMode(): ElevationMode;
+    setMode(mode: ElevationMode): void;
+    isElevated(): boolean;
+    addAllowedCommand(pattern: string | RegExp): void;
+    isCommandAllowed(command: string): boolean;
+    elevate(reason?: string): boolean;
+    revoke(reason?: string): void;
+    canExecute(command: string): {
+        allowed: boolean;
+        needsElevation: boolean;
+    };
+    getAuditLog(): ElevationAuditEntry[];
+    clearAuditLog(): void;
+    private startAutoRevoke;
+    private clearAutoRevoke;
+    destroy(): void;
+}
+//# sourceMappingURL=elevated.d.ts.map

package/dist/security/elevated.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * Elevated Permissions Module - v1.0.0
+ * Elevation mode management with allowed commands, auto-revoke, and audit log.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElevatedManager = void 0;
+class ElevatedManager {
+    mode;
+    elevated = false;
+    allowedCommands = [];
+    auditLog = [];
+    revokeTimer;
+    autoRevokeMs;
+    constructor(options = {}) {
+        this.mode = options.mode ?? 'ask';
+        this.autoRevokeMs = options.autoRevokeMs ?? 600_000; // 10 min
+        if (options.allowedCommands) {
+            for (const cmd of options.allowedCommands) {
+                this.allowedCommands.push(cmd instanceof RegExp ? cmd : new RegExp(`^${cmd.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`));
+            }
+        }
+    }
+    getMode() { return this.mode; }
+    setMode(mode) { this.mode = mode; }
+    isElevated() { return this.elevated; }
+    addAllowedCommand(pattern) {
+        this.allowedCommands.push(pattern instanceof RegExp ? pattern : new RegExp(`^${pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`));
+    }
+    isCommandAllowed(command) {
+        return this.allowedCommands.some(r => r.test(command));
+    }
+    elevate(reason) {
+        if (this.mode === 'off')
+            return false;
+        this.elevated = true;
+        this.auditLog.push({ timestamp: Date.now(), action: 'elevate', reason });
+        this.startAutoRevoke();
+        return true;
+    }
+    revoke(reason) {
+        this.elevated = false;
+        this.clearAutoRevoke();
+        this.auditLog.push({ timestamp: Date.now(), action: 'revoke', reason });
+    }
+    canExecute(command) {
+        if (this.isCommandAllowed(command))
+            return { allowed: true, needsElevation: false };
+        if (this.mode === 'off')
+            return { allowed: true, needsElevation: false };
+        if (this.mode === 'on') {
+            if (!this.elevated)
+                this.elevate('auto-on mode');
+            this.auditLog.push({ timestamp: Date.now(), action: 'execute', command });
+            return { allowed: true, needsElevation: false };
+        }
+        // ask mode
+        if (this.elevated) {
+            this.auditLog.push({ timestamp: Date.now(), action: 'execute', command });
+            return { allowed: true, needsElevation: false };
+        }
+        return { allowed: false, needsElevation: true };
+    }
+    getAuditLog() {
+        return [...this.auditLog];
+    }
+    clearAuditLog() {
+        this.auditLog = [];
+    }
+    startAutoRevoke() {
+        this.clearAutoRevoke();
+        this.revokeTimer = setTimeout(() => {
+            this.revoke('auto-revoke timer');
+        }, this.autoRevokeMs);
+        if (this.revokeTimer.unref)
+            this.revokeTimer.unref();
+    }
+    clearAutoRevoke() {
+        if (this.revokeTimer) {
+            clearTimeout(this.revokeTimer);
+            this.revokeTimer = undefined;
+        }
+    }
+    destroy() {
+        this.clearAutoRevoke();
+    }
+}
+exports.ElevatedManager = ElevatedManager;
+//# sourceMappingURL=elevated.js.map

package/dist/security/index.d.ts

@@ -1,4 +1,10 @@
 export { ApprovalManager } from './approval';
 export type { ApprovalPolicy, ApprovalRequest } from './approval';
 export { KeyManager } from './keys';
+export { ExecApprovalManager } from './approvals';
+export type { ExecApprovalPolicy, ExecApprovalRequest, ExecApprovalHistory, ApprovalRequestCallback } from './approvals';
+export { ElevatedManager } from './elevated';
+export type { ElevationMode, ElevationAuditEntry } from './elevated';
+export { SecretsManager } from './secrets';
+export type { SecretsStore } from './secrets';
 //# sourceMappingURL=index.d.ts.map

package/dist/security/index.js

@@ -1,8 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KeyManager = exports.ApprovalManager = void 0;
+exports.SecretsManager = exports.ElevatedManager = exports.ExecApprovalManager = exports.KeyManager = exports.ApprovalManager = void 0;
 var approval_1 = require("./approval");
 Object.defineProperty(exports, "ApprovalManager", { enumerable: true, get: function () { return approval_1.ApprovalManager; } });
 var keys_1 = require("./keys");
 Object.defineProperty(exports, "KeyManager", { enumerable: true, get: function () { return keys_1.KeyManager; } });
+var approvals_1 = require("./approvals");
+Object.defineProperty(exports, "ExecApprovalManager", { enumerable: true, get: function () { return approvals_1.ExecApprovalManager; } });
+var elevated_1 = require("./elevated");
+Object.defineProperty(exports, "ElevatedManager", { enumerable: true, get: function () { return elevated_1.ElevatedManager; } });
+var secrets_1 = require("./secrets");
+Object.defineProperty(exports, "SecretsManager", { enumerable: true, get: function () { return secrets_1.SecretsManager; } });
 //# sourceMappingURL=index.js.map