tlc-claude-code 1.2.29 → 1.4.0

package/dashboard/dist/components/ZeroRetentionPane.d.ts

@@ -0,0 +1,44 @@
+export interface RetentionRule {
+    retention: string;
+    persist: boolean;
+}
+export interface RetentionPolicy {
+    retention?: string;
+    persist?: boolean;
+    sensitivityLevels?: Record<string, RetentionRule>;
+    dataTypes?: Record<string, RetentionRule>;
+}
+export interface PurgeEntry {
+    id: string;
+    timestamp: string;
+    itemCount: number;
+    dataTypes: string[];
+}
+export interface SensitiveDataInfo {
+    detected: boolean;
+    count: number;
+    types: string[];
+}
+export interface SubsystemStatus {
+    ephemeralStorage?: boolean;
+    sessionPurge?: boolean;
+    memoryExclusion?: boolean;
+}
+export interface ValidationResult {
+    valid: boolean;
+    conflicts: string[];
+    warnings: string[];
+}
+export interface ZeroRetentionPaneProps {
+    enabled?: boolean;
+    policy?: RetentionPolicy;
+    purgeHistory?: PurgeEntry[];
+    sensitiveDataDetected?: SensitiveDataInfo;
+    subsystems?: SubsystemStatus;
+    validation?: ValidationResult;
+    isActive?: boolean;
+    onToggle?: () => void;
+    onPurge?: () => void;
+}
+export declare function ZeroRetentionPane({ enabled, policy, purgeHistory, sensitiveDataDetected, subsystems, validation, isActive, onToggle, onPurge, }: ZeroRetentionPaneProps): import("react/jsx-runtime").JSX.Element;
+export default ZeroRetentionPane;

package/dashboard/dist/components/ZeroRetentionPane.js

@@ -0,0 +1,83 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+function formatTimestamp(ts) {
+    if (!ts)
+        return '';
+    try {
+        const date = new Date(ts);
+        if (isNaN(date.getTime()))
+            return '';
+        const hours = String(date.getUTCHours()).padStart(2, '0');
+        const minutes = String(date.getUTCMinutes()).padStart(2, '0');
+        const seconds = String(date.getUTCSeconds()).padStart(2, '0');
+        return `${hours}:${minutes}:${seconds}`;
+    }
+    catch {
+        return '';
+    }
+}
+function StatusIndicator({ enabled }) {
+    return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "Status: " }), _jsx(Text, { color: enabled ? 'green' : 'gray', bold: true, children: enabled ? 'ENABLED' : 'DISABLED' })] }));
+}
+function SubsystemsList({ subsystems }) {
+    const items = [
+        { key: 'ephemeralStorage', label: 'Ephemeral Storage' },
+        { key: 'sessionPurge', label: 'Session Purge' },
+        { key: 'memoryExclusion', label: 'Memory Exclusion' },
+    ];
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, dimColor: true, children: "Subsystems:" }), items.map((item) => {
+                const active = subsystems[item.key];
+                return (_jsx(Box, { children: _jsxs(Text, { color: active ? 'green' : 'gray', children: [active ? '  [x]' : '  [ ]', " ", item.label] }) }, item.key));
+            })] }));
+}
+function PolicySummary({ policy }) {
+    const rules = [];
+    if (policy.retention) {
+        rules.push({ label: 'Default', value: policy.retention });
+    }
+    if (policy.sensitivityLevels) {
+        Object.entries(policy.sensitivityLevels).forEach(([level, rule]) => {
+            rules.push({ label: level, value: rule.retention });
+        });
+    }
+    if (policy.dataTypes) {
+        Object.entries(policy.dataTypes).forEach(([type, rule]) => {
+            rules.push({ label: type, value: rule.retention });
+        });
+    }
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, dimColor: true, children: "Policy:" }), rules.length === 0 ? (_jsx(Text, { color: "gray", children: "  No policy rules configured" })) : (rules.slice(0, 5).map((rule, idx) => (_jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: ["  ", rule.label, ": "] }), _jsx(Text, { color: rule.value === 'immediate' ? 'cyan' : 'white', children: rule.value })] }, idx)))), rules.length > 5 && (_jsxs(Text, { dimColor: true, children: ["  ... and ", rules.length - 5, " more rules"] }))] }));
+}
+function PurgeHistory({ entries }) {
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, dimColor: true, children: "Recent Purge Activity:" }), entries.length === 0 ? (_jsx(Text, { color: "gray", children: "  No purge history - none yet" })) : (entries.slice(0, 5).map((entry) => {
+                const timestamp = formatTimestamp(entry.timestamp);
+                return (_jsxs(Box, { children: [timestamp && _jsxs(Text, { dimColor: true, children: ["  [", timestamp, "] "] }), _jsxs(Text, { children: ["Purged ", entry.itemCount, " items "] }), _jsxs(Text, { dimColor: true, children: ["(", entry.dataTypes.join(', '), ")"] })] }, entry.id));
+            }))] }));
+}
+function SensitiveWarning({ info }) {
+    if (!info.detected || info.count === 0) {
+        return null;
+    }
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [_jsx(Box, { children: _jsx(Text, { color: "yellow", bold: true, children: "Warning: Sensitive Data Detected" }) }), _jsx(Box, { children: _jsxs(Text, { color: "yellow", children: ["Found ", info.count, " sensitive item(s): ", info.types.join(', ')] }) }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: "Enable zero-retention mode to protect this data" }) })] }));
+}
+function ValidationStatus({ validation }) {
+    if (validation.valid && validation.warnings.length === 0) {
+        return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "green", children: "Configuration: Valid and OK" }) }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [validation.conflicts.length > 0 && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "red", bold: true, children: "Conflicts:" }), validation.conflicts.map((conflict, idx) => (_jsxs(Text, { color: "red", children: ["  - ", conflict] }, idx)))] })), validation.warnings.length > 0 && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "yellow", bold: true, children: "Warnings:" }), validation.warnings.map((warning, idx) => (_jsxs(Text, { color: "yellow", children: ["  - ", warning] }, idx)))] }))] }));
+}
+export function ZeroRetentionPane({ enabled = false, policy, purgeHistory = [], sensitiveDataDetected, subsystems, validation, isActive = false, onToggle, onPurge, }) {
+    useInput((input, _key) => {
+        if (!isActive)
+            return;
+        // Toggle with 't'
+        if (input === 't' && onToggle) {
+            onToggle();
+        }
+        // Force purge with 'p'
+        if (input === 'p' && onPurge) {
+            onPurge();
+        }
+    }, { isActive });
+    return (_jsxs(Box, { padding: 1, flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Zero-Retention Mode" }) }), _jsx(StatusIndicator, { enabled: enabled }), sensitiveDataDetected && (_jsx(SensitiveWarning, { info: sensitiveDataDetected })), validation && _jsx(ValidationStatus, { validation: validation }), subsystems && _jsx(SubsystemsList, { subsystems: subsystems }), policy && _jsx(PolicySummary, { policy: policy }), _jsx(PurgeHistory, { entries: purgeHistory }), isActive && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["[t] Toggle ", enabled ? 'disable' : 'enable', enabled && '  [p] Force purge'] }) }))] }));
+}
+export default ZeroRetentionPane;

package/dashboard/dist/components/ZeroRetentionPane.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dashboard/dist/components/ZeroRetentionPane.test.js

@@ -0,0 +1,160 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render } from 'ink-testing-library';
+import { ZeroRetentionPane } from './ZeroRetentionPane.js';
+describe('ZeroRetentionPane', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    describe('enabled state', () => {
+        it('renders enabled state correctly', () => {
+            const { lastFrame } = render(_jsx(ZeroRetentionPane, { enabled: true }));
+            const output = lastFrame();
+            expect(output).toContain('Zero-Retention');
+            expect(output).toMatch(/enabled|active|on/i);
+        });
+    });
+    describe('disabled state', () => {
+        it('renders disabled state correctly', () => {
+            const { lastFrame } = render(_jsx(ZeroRetentionPane, { enabled: false }));
+            const output = lastFrame();
+            expect(output).toContain('Zero-Retention');
+            expect(output).toMatch(/disabled|inactive|off/i);
+        });
+    });
+    describe('toggle callback', () => {
+        it('toggle calls onToggle callback', () => {
+            const onToggle = vi.fn();
+            const { lastFrame } = render(_jsx(ZeroRetentionPane, { enabled: false, isActive: true, onToggle: onToggle }));
+            // Verify toggle control is shown when active and onToggle is provided
+            const output = lastFrame();
+            expect(output).toMatch(/\[t\]|toggle/i);
+        });
+    });
+    describe('retention policy summary', () => {
+        it('shows retention policy summary', () => {
+            const policy = {
+                retention: 'immediate',
+                persist: false,
+                sensitivityLevels: {
+                    critical: { retention: 'immediate', persist: false },
+                    high: { retention: 'immediate', persist: false },
+                    medium: { retention: 'session', persist: false },
+                    low: { retention: '24h', persist: true },
+                },
+            };
+            const { lastFrame } = render(_jsx(ZeroRetentionPane, { enabled: true, policy: policy }));
+            const output = lastFrame();
+            expect(output).toContain('Policy');
+            expect(output).toMatch(/immediate|session|purge/i);
+        });
+    });
+    describe('purge activity list', () => {
+        it('shows purge activity list', () => {
+            const purgeHistory = [
+                {
+                    id: '1',
+                    timestamp: '2024-01-15T10:30:00.000Z',
+                    itemCount: 5,
+                    dataTypes: ['secrets', 'pii'],
+                },
+                {
+                    id: '2',
+                    timestamp: '2024-01-15T10:35:00.000Z',
+                    itemCount: 3,
+                    dataTypes: ['general'],
+                },
+            ];
+            const { lastFrame } = render(_jsx(ZeroRetentionPane, { enabled: true, purgeHistory: purgeHistory }));
+            const output = lastFrame();
+            expect(output).toContain('Purge');
+            expect(output).toContain('5');
+            expect(output).toContain('3');
+        });
+    });
+    describe('sensitive data warning', () => {
+        it('shows warning for sensitive data', () => {
+            const sensitiveDataDetected = {
+                detected: true,
+                count: 3,
+                types: ['api_key', 'password', 'pii'],
+            };
+            const { lastFrame } = render(_jsx(ZeroRetentionPane, { enabled: true, sensitiveDataDetected: sensitiveDataDetected }));
+            const output = lastFrame();
+            expect(output).toMatch(/warning|sensitive|detected/i);
+            expect(output).toContain('3');
+        });
+    });
+    describe('empty purge history', () => {
+        it('handles empty purge history', () => {
+            const { lastFrame } = render(_jsx(ZeroRetentionPane, { enabled: true, purgeHistory: [] }));
+            const output = lastFrame();
+            expect(output).toContain('Zero-Retention');
+            expect(output).toMatch(/no.*purge|empty|none/i);
+        });
+    });
+    describe('policy formatting', () => {
+        it('formats policy for display', () => {
+            const policy = {
+                retention: 'immediate',
+                persist: false,
+                dataTypes: {
+                    secrets: { retention: 'immediate', persist: false },
+                    pii: { retention: 'session', persist: false },
+                    general: { retention: '7d', persist: true },
+                },
+            };
+            const { lastFrame } = render(_jsx(ZeroRetentionPane, { enabled: true, policy: policy }));
+            const output = lastFrame();
+            // Should display policy rules in a readable format
+            expect(output).toContain('Policy');
+            expect(output).toBeDefined();
+        });
+    });
+    describe('subsystem status', () => {
+        it('shows subsystem status when provided', () => {
+            const subsystems = {
+                ephemeralStorage: true,
+                sessionPurge: true,
+                memoryExclusion: true,
+            };
+            const { lastFrame } = render(_jsx(ZeroRetentionPane, { enabled: true, subsystems: subsystems }));
+            const output = lastFrame();
+            expect(output).toMatch(/ephemeral|storage/i);
+            expect(output).toMatch(/session|purge/i);
+        });
+    });
+    describe('configuration validation', () => {
+        it('shows validation warnings when present', () => {
+            const validation = {
+                valid: false,
+                conflicts: ['Ephemeral storage has basePath set'],
+                warnings: ['Audit logging conflicts with zero-retention'],
+            };
+            const { lastFrame } = render(_jsx(ZeroRetentionPane, { enabled: true, validation: validation }));
+            const output = lastFrame();
+            expect(output).toMatch(/conflict|warning/i);
+        });
+        it('shows valid status when no conflicts', () => {
+            const validation = {
+                valid: true,
+                conflicts: [],
+                warnings: [],
+            };
+            const { lastFrame } = render(_jsx(ZeroRetentionPane, { enabled: true, validation: validation }));
+            const output = lastFrame();
+            expect(output).toMatch(/valid|ok|configured/i);
+        });
+    });
+    describe('keyboard controls', () => {
+        it('shows controls when active', () => {
+            const { lastFrame } = render(_jsx(ZeroRetentionPane, { enabled: false, isActive: true }));
+            const output = lastFrame();
+            // Should show control hints
+            expect(output).toMatch(/\[t\]|toggle|enable|disable/i);
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tlc-claude-code",
-  "version": "1.2.29",
+  "version": "1.4.0",
   "description": "TLC - Test Led Coding for Claude Code",
   "bin": {
     "tlc": "./bin/tlc.js",