sandstream-kit 1.0.0

package/dist/query-optimizer.js

@@ -0,0 +1,199 @@
+// ─── Types ────────────────────────────────────────────────────────────────────
+// ─── QueryOptimizer ───────────────────────────────────────────────────────────
+export class QueryOptimizer {
+    queryCache = new Map();
+    indexes = new Map();
+    executionStats = [];
+    batchQueue = new Map();
+    // ─── Index Management ─────────────────────────────────────────────────────
+    /**
+     * Create an index for faster queries.
+     */
+    createIndex(indexDef) {
+        this.indexes.set(indexDef.name, indexDef);
+    }
+    /**
+     * Get index definition by name.
+     */
+    getIndex(indexName) {
+        return this.indexes.get(indexName) || null;
+    }
+    /**
+     * Get all indexes.
+     */
+    getAllIndexes() {
+        return [...this.indexes.values()];
+    }
+    /**
+     * Drop an index.
+     */
+    dropIndex(indexName) {
+        return this.indexes.delete(indexName);
+    }
+    // ─── Query Planning ───────────────────────────────────────────────────────
+    /**
+     * Generate optimized query plan.
+     */
+    planQuery(query, columns = []) {
+        // Check cache first
+        if (this.queryCache.has(query)) {
+            return this.queryCache.get(query);
+        }
+        // Analyze query and find applicable indexes
+        const indexesUsed = this.findApplicableIndexes(query, columns);
+        const estimatedCost = this.calculateQueryCost(query, indexesUsed);
+        const batchSize = this.recommendBatchSize(estimatedCost);
+        const useConnection = estimatedCost >= 1000;
+        const plan = {
+            query,
+            estimatedCost,
+            indexesUsed,
+            batchSize,
+            useConnection,
+        };
+        this.queryCache.set(query, plan);
+        return plan;
+    }
+    findApplicableIndexes(query, columns) {
+        const applicable = [];
+        for (const index of this.indexes.values()) {
+            // Check if index columns are referenced in query
+            if (index.columns.some((col) => query.includes(col) || columns.includes(col))) {
+                applicable.push(index.name);
+            }
+        }
+        return applicable;
+    }
+    calculateQueryCost(query, indexesUsed) {
+        // Simple cost calculation: base cost minus index benefits
+        let cost = 200;
+        // Penalize complex queries
+        if (query.includes("JOIN"))
+            cost += 400;
+        if (query.includes("GROUP BY"))
+            cost += 300;
+        if (query.includes("ORDER BY"))
+            cost += 200;
+        // Reward index usage
+        cost -= indexesUsed.length * 50;
+        return Math.max(10, cost);
+    }
+    recommendBatchSize(estimatedCost) {
+        if (estimatedCost < 50)
+            return 1000;
+        if (estimatedCost < 100)
+            return 500;
+        if (estimatedCost < 500)
+            return 100;
+        return 10;
+    }
+    /**
+     * Get cached query plan.
+     */
+    getCachedPlan(query) {
+        return this.queryCache.get(query) || null;
+    }
+    /**
+     * Clear query plan cache.
+     */
+    clearCache() {
+        this.queryCache.clear();
+    }
+    // ─── Query Execution ──────────────────────────────────────────────────────
+    /**
+     * Execute query with optimization.
+     */
+    executeQuery(query, columns = []) {
+        const startTime = Date.now();
+        const plan = this.planQuery(query, columns);
+        // Simulate query execution
+        const result = {
+            rows: [],
+            executionTime: Date.now() - startTime,
+            indexesUsed: plan.indexesUsed,
+        };
+        // Track statistics
+        this.executionStats.push({
+            query,
+            executionTime: result.executionTime,
+            timestamp: new Date().toISOString(),
+        });
+        return result;
+    }
+    /**
+     * Get query execution statistics.
+     */
+    getExecutionStats(limit = 100) {
+        return this.executionStats.slice(-limit);
+    }
+    /**
+     * Get average query execution time.
+     */
+    getAverageExecutionTime(query) {
+        const stats = query
+            ? this.executionStats.filter((s) => s.query === query)
+            : this.executionStats;
+        if (stats.length === 0)
+            return 0;
+        const total = stats.reduce((sum, s) => sum + s.executionTime, 0);
+        return total / stats.length;
+    }
+    // ─── Batch Operations ─────────────────────────────────────────────────────
+    /**
+     * Queue batch operation.
+     */
+    queueBatchOperation(id, operations) {
+        const batchOp = {
+            id,
+            operations,
+            status: "pending",
+        };
+        this.batchQueue.set(id, batchOp);
+        return batchOp;
+    }
+    /**
+     * Execute queued batch operation.
+     */
+    executeBatch(id) {
+        const batch = this.batchQueue.get(id);
+        if (!batch)
+            return null;
+        batch.status = "executing";
+        try {
+            // Simulate batch execution
+            batch.result = {
+                inserted: batch.operations.filter((op) => op.type === "insert").length,
+                updated: batch.operations.filter((op) => op.type === "update").length,
+                deleted: batch.operations.filter((op) => op.type === "delete").length,
+            };
+            batch.status = "completed";
+        }
+        catch {
+            batch.status = "failed";
+        }
+        return batch;
+    }
+    /**
+     * Get batch operation by ID.
+     */
+    getBatchOperation(id) {
+        return this.batchQueue.get(id) || null;
+    }
+    /**
+     * Get all pending batches.
+     */
+    getPendingBatches() {
+        return [...this.batchQueue.values()].filter((b) => b.status === "pending");
+    }
+    // ─── Cache helpers ────────────────────────────────────────────────────────
+    getIndexCache() {
+        return this.indexes;
+    }
+    getQueryCacheSize() {
+        return this.queryCache.size;
+    }
+    getBatchQueueSize() {
+        return this.batchQueue.size;
+    }
+}
+//# sourceMappingURL=query-optimizer.js.map

package/dist/query-optimizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-optimizer.js","sourceRoot":"","sources":["../src/query-optimizer.ts"],"names":[],"mappings":"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"}

package/dist/read-only-mode.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Per-session read-only mode.
+ *
+ * When kit is invoked with `--read-only` (or `.kit.toml [policy]
+ * .default_mode = "read-only"`), every write-capable code path refuses
+ * the mutation and audit-logs the refusal. The set of guarded operations
+ * includes: vault writes, env-var sets, hook installs, elevation grants,
+ * and every plugin's create/update/delete surface.
+ *
+ * Implementation choice: a single env var `KIT_READ_ONLY=1` is the
+ * source of truth so plugins running in the same process tree honor the
+ * flag without explicit coupling to a TypeScript module.
+ */
+/**
+ * Returns true when the active process should refuse mutating operations.
+ * Honors:
+ *   1. Explicit `--read-only` flag (parsed by main(), sets env var)
+ *   2. `KIT_READ_ONLY=1` env var (for nested invocations)
+ *   3. `.kit.toml [policy].default_mode = "read-only"` (read at boot)
+ */
+export declare function isReadOnlyMode(): boolean;
+/**
+ * Activates read-only mode for this process and any child processes.
+ * Idempotent. Called from main() after argv parsing or from
+ * `.kit.toml`-policy loader.
+ */
+export declare function activateReadOnlyMode(source: "flag" | "env" | "policy"): void;
+/**
+ * Refuses a mutating operation. Returns a structured result that callers
+ * forward; also appends an audit-log entry. Never throws — callers handle
+ * the {ok: false} branch and surface the reason to the user.
+ *
+ * Pattern:
+ *   if (isReadOnlyMode()) {
+ *     const refusal = await refuseWrite("rotate-jwt", { vault: "supabase" });
+ *     return { ok: false, detail: refusal.reason };
+ *   }
+ */
+export declare function refuseWrite(operation: string, metadata?: Record<string, unknown>): Promise<{
+    ok: false;
+    reason: string;
+}>;
+/**
+ * Test-only: reset env var so tests can exercise both modes.
+ */
+export declare function _resetReadOnlyModeForTests(): void;

package/dist/read-only-mode.js

@@ -0,0 +1,71 @@
+/**
+ * Per-session read-only mode.
+ *
+ * When kit is invoked with `--read-only` (or `.kit.toml [policy]
+ * .default_mode = "read-only"`), every write-capable code path refuses
+ * the mutation and audit-logs the refusal. The set of guarded operations
+ * includes: vault writes, env-var sets, hook installs, elevation grants,
+ * and every plugin's create/update/delete surface.
+ *
+ * Implementation choice: a single env var `KIT_READ_ONLY=1` is the
+ * source of truth so plugins running in the same process tree honor the
+ * flag without explicit coupling to a TypeScript module.
+ */
+import { appendAuditEventDirect } from "./audit.js";
+const READ_ONLY_ENV = "KIT_READ_ONLY";
+/**
+ * Returns true when the active process should refuse mutating operations.
+ * Honors:
+ *   1. Explicit `--read-only` flag (parsed by main(), sets env var)
+ *   2. `KIT_READ_ONLY=1` env var (for nested invocations)
+ *   3. `.kit.toml [policy].default_mode = "read-only"` (read at boot)
+ */
+export function isReadOnlyMode() {
+    const v = process.env[READ_ONLY_ENV];
+    return v === "1" || v === "true";
+}
+/**
+ * Activates read-only mode for this process and any child processes.
+ * Idempotent. Called from main() after argv parsing or from
+ * `.kit.toml`-policy loader.
+ */
+export function activateReadOnlyMode(source) {
+    if (isReadOnlyMode())
+        return;
+    process.env[READ_ONLY_ENV] = "1";
+    process.stderr.write(`[kit] read-only mode active (source: ${source}) — all writes will be refused.\n`);
+    void appendAuditEventDirect({
+        operation: "read-only-mode-activated",
+        environment: process.env.NODE_ENV ?? "unknown",
+        success: true,
+        metadata: { source },
+    });
+}
+/**
+ * Refuses a mutating operation. Returns a structured result that callers
+ * forward; also appends an audit-log entry. Never throws — callers handle
+ * the {ok: false} branch and surface the reason to the user.
+ *
+ * Pattern:
+ *   if (isReadOnlyMode()) {
+ *     const refusal = await refuseWrite("rotate-jwt", { vault: "supabase" });
+ *     return { ok: false, detail: refusal.reason };
+ *   }
+ */
+export async function refuseWrite(operation, metadata = {}) {
+    const reason = `read-only mode active — refusing "${operation}"`;
+    await appendAuditEventDirect({
+        operation: "read-only-mode-refusal",
+        environment: process.env.NODE_ENV ?? "unknown",
+        success: false,
+        metadata: { refused_operation: operation, ...metadata },
+    });
+    return { ok: false, reason };
+}
+/**
+ * Test-only: reset env var so tests can exercise both modes.
+ */
+export function _resetReadOnlyModeForTests() {
+    delete process.env[READ_ONLY_ENV];
+}
+//# sourceMappingURL=read-only-mode.js.map

package/dist/read-only-mode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-only-mode.js","sourceRoot":"","sources":["../src/read-only-mode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEpD,MAAM,aAAa,GAAG,eAAe,CAAC;AAEtC;;;;;;GAMG;AACH,MAAM,UAAU,cAAc;IAC5B,MAAM,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;IACrC,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,MAAM,CAAC;AACnC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAAiC;IACpE,IAAI,cAAc,EAAE;QAAE,OAAO;IAC7B,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,GAAG,GAAG,CAAC;IACjC,OAAO,CAAC,MAAM,CAAC,KAAK,CAClB,wCAAwC,MAAM,mCAAmC,CAClF,CAAC;IACF,KAAK,sBAAsB,CAAC;QAC1B,SAAS,EAAE,0BAA0B;QACrC,WAAW,EAAE,OAAO,CAAC,GAAG,CAAC,QAAQ,IAAI,SAAS;QAC9C,OAAO,EAAE,IAAI;QACb,QAAQ,EAAE,EAAE,MAAM,EAAE;KACrB,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,SAAiB,EACjB,WAAoC,EAAE;IAEtC,MAAM,MAAM,GAAG,qCAAqC,SAAS,GAAG,CAAC;IACjE,MAAM,sBAAsB,CAAC;QAC3B,SAAS,EAAE,wBAAwB;QACnC,WAAW,EAAE,OAAO,CAAC,GAAG,CAAC,QAAQ,IAAI,SAAS;QAC9C,OAAO,EAAE,KAAK;QACd,QAAQ,EAAE,EAAE,iBAAiB,EAAE,SAAS,EAAE,GAAG,QAAQ,EAAE;KACxD,CAAC,CAAC;IACH,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;AAC/B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,0BAA0B;IACxC,OAAO,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;AACpC,CAAC"}

package/dist/redis-adapter.d.ts

@@ -0,0 +1,71 @@
+import { AbstractServiceAdapter, type ServiceConfig, type ServiceEvent, type ServiceHealth } from "./service-adapter.js";
+/**
+ * Redis adapter for caching and session management.
+ */
+export declare class RedisAdapter extends AbstractServiceAdapter {
+    private cache;
+    private lastHealthCheck;
+    private healthCheckErrors;
+    private stats;
+    constructor(config?: ServiceConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    getHealth(): Promise<ServiceHealth>;
+    protected sendEvent(event: ServiceEvent): Promise<void>;
+    /**
+     * Set a cache value.
+     */
+    set(key: string, value: unknown, ttl?: number): Promise<boolean>;
+    /**
+     * Get a cache value.
+     */
+    get(key: string): Promise<unknown>;
+    /**
+     * Delete a cache key.
+     */
+    delete(key: string): Promise<boolean>;
+    /**
+     * Check if key exists.
+     */
+    exists(key: string): Promise<boolean>;
+    /**
+     * Clear all cache.
+     */
+    clear(): Promise<boolean>;
+    /**
+     * Get all cache keys.
+     */
+    keys(): string[];
+    /**
+     * Get cache size.
+     */
+    size(): number;
+    /**
+     * Get cache statistics.
+     */
+    getCacheStats(): {
+        hits: number;
+        misses: number;
+        sets: number;
+        deletes: number;
+        hitRate: number;
+        size: number;
+    };
+    /**
+     * Flush all queued events.
+     */
+    private flushQueue;
+    /**
+     * Get Redis configuration info.
+     */
+    getInfo(): {
+        endpoint: string;
+        connected: boolean;
+        cacheSize: number;
+        keyCount: number;
+    };
+}
+/**
+ * Create a Redis adapter from environment variables.
+ */
+export declare function createRedisAdapter(enabled?: boolean): RedisAdapter;

package/dist/redis-adapter.js

@@ -0,0 +1,278 @@
+// ─── Redis Cache Adapter ─────────────────────────────────────────────────
+import { AbstractServiceAdapter, simulatedFailuresEnabled, } from "./service-adapter.js";
+/**
+ * Redis adapter for caching and session management.
+ */
+export class RedisAdapter extends AbstractServiceAdapter {
+    cache = new Map();
+    lastHealthCheck = new Date().toISOString();
+    healthCheckErrors = 0;
+    stats = {
+        hits: 0,
+        misses: 0,
+        sets: 0,
+        deletes: 0,
+    };
+    constructor(config = { enabled: false }) {
+        super("redis", "1.0.0", config);
+    }
+    async connect() {
+        if (!this.config.enabled) {
+            this.connected = false;
+            return;
+        }
+        // Validate required config
+        if (!this.config.endpoint) {
+            throw new Error("Redis endpoint is required (host:port)");
+        }
+        // Basic endpoint format validation
+        const [host, port] = this.config.endpoint.split(":");
+        if (!host) {
+            throw new Error("Invalid Redis endpoint format");
+        }
+        if (port && isNaN(parseInt(port))) {
+            throw new Error("Invalid Redis port number");
+        }
+        // Simulate connection test
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        this.connected = true;
+        // Flush queued events
+        await this.flushQueue();
+    }
+    async disconnect() {
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+            this.healthCheckInterval = null;
+        }
+        this.cache.clear();
+        this.connected = false;
+    }
+    async getHealth() {
+        const responseTime = Math.random() * 30;
+        try {
+            if (!this.connected) {
+                this.healthCheckErrors++;
+            }
+            this.lastHealthCheck = new Date().toISOString();
+            const status = this.healthCheckErrors < 3
+                ? this.connected
+                    ? "healthy"
+                    : "degraded"
+                : "unhealthy";
+            return {
+                status,
+                lastCheck: this.lastHealthCheck,
+                responseTime: Math.round(responseTime),
+                errorCount: this.healthCheckErrors,
+            };
+        }
+        catch {
+            this.healthCheckErrors++;
+            return {
+                status: "unhealthy",
+                lastCheck: new Date().toISOString(),
+                responseTime: -1,
+                errorCount: this.healthCheckErrors,
+            };
+        }
+    }
+    async sendEvent(event) {
+        if (!this.connected) {
+            throw new Error("Not connected to Redis");
+        }
+        // Validate event
+        if (!event.type || !event.data) {
+            throw new Error("Invalid event format");
+        }
+        // Simulate Redis operation
+        await new Promise((resolve) => setTimeout(resolve, Math.random() * 20));
+        // Simulate occasional failures (0.5% rate for Redis)
+        if (simulatedFailuresEnabled() && Math.random() < 0.005) {
+            throw new Error("Simulated Redis error");
+        }
+    }
+    /**
+     * Set a cache value.
+     */
+    async set(key, value, ttl) {
+        const expireAt = ttl ? Date.now() + ttl * 1000 : undefined;
+        const event = {
+            type: "event",
+            data: {
+                operation: "set",
+                key,
+                value,
+                ttl,
+            },
+            timestamp: new Date().toISOString(),
+            tags: {
+                operation: "set",
+            },
+        };
+        const success = await this.send(event);
+        if (success) {
+            this.cache.set(key, { value, expireAt });
+            this.stats.sets++;
+        }
+        return success;
+    }
+    /**
+     * Get a cache value.
+     */
+    async get(key) {
+        const event = {
+            type: "event",
+            data: {
+                operation: "get",
+                key,
+            },
+            timestamp: new Date().toISOString(),
+            tags: {
+                operation: "get",
+            },
+        };
+        await this.send(event);
+        const entry = this.cache.get(key);
+        if (!entry) {
+            this.stats.misses++;
+            return undefined;
+        }
+        // Check expiration
+        if (entry.expireAt && entry.expireAt < Date.now()) {
+            this.cache.delete(key);
+            this.stats.misses++;
+            return undefined;
+        }
+        this.stats.hits++;
+        return entry.value;
+    }
+    /**
+     * Delete a cache key.
+     */
+    async delete(key) {
+        const event = {
+            type: "event",
+            data: {
+                operation: "delete",
+                key,
+            },
+            timestamp: new Date().toISOString(),
+            tags: {
+                operation: "delete",
+            },
+        };
+        const success = await this.send(event);
+        if (success) {
+            const deleted = this.cache.delete(key);
+            if (deleted) {
+                this.stats.deletes++;
+            }
+        }
+        return success;
+    }
+    /**
+     * Check if key exists.
+     */
+    async exists(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            return false;
+        }
+        // Check expiration
+        if (entry.expireAt && entry.expireAt < Date.now()) {
+            this.cache.delete(key);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Clear all cache.
+     */
+    async clear() {
+        const event = {
+            type: "event",
+            data: {
+                operation: "clear",
+            },
+            timestamp: new Date().toISOString(),
+            tags: {
+                operation: "clear",
+            },
+        };
+        const success = await this.send(event);
+        if (success) {
+            this.cache.clear();
+        }
+        return success;
+    }
+    /**
+     * Get all cache keys.
+     */
+    keys() {
+        const now = Date.now();
+        const validKeys = [];
+        for (const [key, entry] of this.cache.entries()) {
+            // Skip expired keys
+            if (!entry.expireAt || entry.expireAt >= now) {
+                validKeys.push(key);
+            }
+        }
+        return validKeys;
+    }
+    /**
+     * Get cache size.
+     */
+    size() {
+        return this.cache.size;
+    }
+    /**
+     * Get cache statistics.
+     */
+    getCacheStats() {
+        const total = this.stats.hits + this.stats.misses;
+        const hitRate = total > 0 ? (this.stats.hits / total) * 100 : 0;
+        return {
+            ...this.stats,
+            hitRate: Math.round(hitRate * 100) / 100,
+            size: this.cache.size,
+        };
+    }
+    /**
+     * Flush all queued events.
+     */
+    async flushQueue() {
+        const queued = this.getQueuedEvents();
+        if (queued.length === 0)
+            return;
+        const { sent, failed } = await this.batch(queued);
+        if (sent > 0) {
+            this.clearQueue();
+        }
+        console.log(`Flushed Redis queue: ${sent} sent, ${failed} failed`);
+    }
+    /**
+     * Get Redis configuration info.
+     */
+    getInfo() {
+        return {
+            endpoint: this.config.endpoint || "",
+            connected: this.connected,
+            cacheSize: this.cache.size,
+            keyCount: this.keys().length,
+        };
+    }
+}
+/**
+ * Create a Redis adapter from environment variables.
+ */
+export function createRedisAdapter(enabled = true) {
+    const endpoint = process.env.REDIS_URL || process.env.REDIS_ENDPOINT;
+    if (enabled && !endpoint) {
+        console.warn("Redis is enabled but REDIS_URL/REDIS_ENDPOINT environment variable is not set");
+    }
+    return new RedisAdapter({
+        enabled: enabled && !!endpoint,
+        endpoint,
+    });
+}
+//# sourceMappingURL=redis-adapter.js.map