@adhdev/daemon-core 0.5.3

package/src/config/chat-history.ts

@@ -0,0 +1,211 @@
+/**
+ * Chat History Persistence — Persist completed chat messages to local disk
+ * 
+ * Design:
+ * - ~/.adhdev/history/{agentType}/YYYY-MM-DD.jsonl
+ * - JSONL format (one line = one message, append-friendly)
+ * - Track only new messages (hash comparison with previous)
+ * - Auto-rotation (delete files older than 30 days)
+ * - Async/non-blocking (no impact on chat collection)
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+const HISTORY_DIR = path.join(os.homedir(), '.adhdev', 'history');
+const RETAIN_DAYS = 30;
+
+interface HistoryMessage {
+    ts: string;           // ISO timestamp
+    receivedAt: number;   // epoch ms
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    agent: string;        // e.g. 'antigravity', 'cursor', 'gemini-cli'
+    instanceId?: string;  // IDE instance UUID (distinguishes windows of the same agent type)
+    sessionTitle?: string;
+}
+
+export class ChatHistoryWriter {
+ /** Last seen message count per agent (deduplication) */
+    private lastSeenCounts = new Map<string, number>();
+ /** Last seen message hash per agent (deduplication) */
+    private lastSeenHashes = new Map<string, Set<string>>();
+    private rotated = false;
+
+ /**
+ * Append new messages to history
+ * 
+ * @param agentType agent type (e.g. 'antigravity', 'cursor')
+ * @param messages Message array received from readChat
+ * @param sessionTitle Current session title
+ * @param instanceId IDE instance UUID (distinguishes windows of the same agent)
+ */
+    appendNewMessages(
+        agentType: string,
+        messages: Array<{ role: string; content: string; receivedAt?: number }>,
+        sessionTitle?: string,
+        instanceId?: string,
+    ): void {
+        if (!messages || messages.length === 0) return;
+
+        try {
+ // dedup key: agentType + instanceId
+            const dedupKey = instanceId ? `${agentType}:${instanceId}` : agentType;
+            let seenHashes = this.lastSeenHashes.get(dedupKey);
+            if (!seenHashes) {
+                seenHashes = new Set<string>();
+                this.lastSeenHashes.set(dedupKey, seenHashes);
+            }
+
+ // Filter new messages
+            const newMessages: HistoryMessage[] = [];
+            for (const msg of messages) {
+                const hash = `${msg.role}:${(msg.content || '').slice(0, 50)}`;
+                if (seenHashes.has(hash)) continue;
+                seenHashes.add(hash);
+                newMessages.push({
+                    ts: new Date(msg.receivedAt || Date.now()).toISOString(),
+                    receivedAt: msg.receivedAt || Date.now(),
+                    role: msg.role as 'user' | 'assistant' | 'system',
+                    content: msg.content || '',
+                    agent: agentType,
+                    instanceId,
+                    sessionTitle,
+                });
+            }
+
+            if (newMessages.length === 0) return;
+
+ // Append to file — separate file if instanceId exists
+            const dir = path.join(HISTORY_DIR, this.sanitize(agentType));
+            fs.mkdirSync(dir, { recursive: true });
+
+            const date = new Date().toISOString().slice(0, 10); // YYYY-MM-DD
+            const filePrefix = instanceId ? `${this.sanitize(instanceId)}_` : '';
+            const filePath = path.join(dir, `${filePrefix}${date}.jsonl`);
+            const lines = newMessages.map(m => JSON.stringify(m)).join('\n') + '\n';
+            fs.appendFileSync(filePath, lines, 'utf-8');
+
+ // Detect session switch — reset hash if message count decreases
+            const prevCount = this.lastSeenCounts.get(dedupKey) || 0;
+            if (messages.length < prevCount * 0.5 && prevCount > 3) {
+                seenHashes.clear();
+                for (const msg of messages) {
+                    seenHashes.add(`${msg.role}:${(msg.content || '').slice(0, 50)}`);
+                }
+            }
+            this.lastSeenCounts.set(dedupKey, messages.length);
+
+ // Rotate only once on first call
+            if (!this.rotated) {
+                this.rotated = true;
+                this.rotateOldFiles().catch(() => {});
+            }
+        } catch {
+ // Ignore history save failures (must not affect main functionality)
+        }
+    }
+
+ /** Called when agent session is explicitly changed */
+    onSessionChange(agentType: string): void {
+        this.lastSeenHashes.delete(agentType);
+        this.lastSeenCounts.delete(agentType);
+    }
+
+ /** Delete history files older than 30 days */
+    private async rotateOldFiles(): Promise<void> {
+        try {
+            if (!fs.existsSync(HISTORY_DIR)) return;
+            const cutoff = Date.now() - RETAIN_DAYS * 24 * 60 * 60 * 1000;
+
+            const agentDirs = fs.readdirSync(HISTORY_DIR, { withFileTypes: true })
+                .filter(d => d.isDirectory());
+
+            for (const dir of agentDirs) {
+                const dirPath = path.join(HISTORY_DIR, dir.name);
+                const files = fs.readdirSync(dirPath)
+                    .filter(f => f.endsWith('.jsonl'));
+
+                for (const file of files) {
+                    const filePath = path.join(dirPath, file);
+                    const stat = fs.statSync(filePath);
+                    if (stat.mtimeMs < cutoff) {
+                        fs.unlinkSync(filePath);
+                    }
+                }
+            }
+        } catch {
+ // Ignore rotate failure
+        }
+    }
+
+ /** Allow only filename-safe characters */
+    private sanitize(name: string): string {
+        return name.replace(/[^a-zA-Z0-9_-]/g, '_');
+    }
+}
+
+/**
+ * Read history (static — called from P2P commands)
+ * 
+ * Read JSONL files in reverse order, returning most recent messages first.
+ * When instanceId is specified, reads only that instance file.
+ * Offset/limit-based paging.
+ */
+export function readChatHistory(
+    agentType: string,
+    offset: number = 0,
+    limit: number = 30,
+    instanceId?: string,
+): { messages: HistoryMessage[]; hasMore: boolean } {
+    try {
+        const sanitized = agentType.replace(/[^a-zA-Z0-9_-]/g, '_');
+        const dir = path.join(HISTORY_DIR, sanitized);
+        if (!fs.existsSync(dir)) return { messages: [], hasMore: false };
+
+ // JSONL file list — only matching prefix if instanceId is specified
+        const sanitizedInstance = instanceId?.replace(/[^a-zA-Z0-9_-]/g, '_');
+        const files = fs.readdirSync(dir)
+            .filter(f => {
+                if (!f.endsWith('.jsonl')) return false;
+                if (sanitizedInstance) {
+                    return f.startsWith(`${sanitizedInstance}_`);
+                }
+ // Without instanceId, only files without prefix (legacy compatible)
+                return !f.includes('_') || f.match(/^\d{4}-\d{2}-\d{2}\.jsonl$/);
+            })
+            .sort()
+            .reverse();
+
+ // Read lines from all files (reverse order)
+        const allMessages: HistoryMessage[] = [];
+        const needed = offset + limit + 1; // hasMore check +1
+
+        for (const file of files) {
+            if (allMessages.length >= needed) break;
+            const filePath = path.join(dir, file);
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const lines = content.trim().split('\n').filter(Boolean);
+            
+ // Parse in reverse order
+            for (let i = lines.length - 1; i >= 0; i--) {
+                if (allMessages.length >= needed) break;
+                try {
+                    allMessages.push(JSON.parse(lines[i]));
+                } catch { /* skip invalid lines */ }
+            }
+        }
+
+ // offset/limit apply
+        const sliced = allMessages.slice(offset, offset + limit);
+        const hasMore = allMessages.length > offset + limit;
+
+ // Sort in chronological order (top→bottom = oldest→newest)
+        sliced.reverse();
+
+        return { messages: sliced, hasMore };
+    } catch {
+        return { messages: [], hasMore: false };
+    }
+}

package/src/config/config.ts

@@ -0,0 +1,219 @@
+/**
+ * ADHDev Launcher — Configuration
+ * 
+ * Manages launcher config, server connection tokens, and user preferences.
+ */
+
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from 'fs';
+
+export interface ADHDevConfig {
+ // Server connection
+    serverUrl: string;
+    apiToken: string | null;
+    connectionToken: string | null;
+
+ // Selected IDE (primary)
+    selectedIde: string | null;
+
+ // All configured IDEs (multiple)
+    configuredIdes: string[];
+
+ // Installed extensions
+    installedExtensions: string[];
+
+ // User preferences
+    autoConnect: boolean;
+    notifications: boolean;
+
+ // Auth
+    userEmail: string | null;
+    userName: string | null;
+
+ // Setup state
+    setupCompleted: boolean;
+    setupDate: string | null;
+
+ // Configured CLI agents
+    configuredCLIs: string[];
+
+ // Daemon: which IDEs to connect (empty = all)
+    enabledIdes: string[];
+    recentCliWorkspaces: string[];
+
+ // Machine nickname (user-customizable label for this machine)
+    machineNickname: string | null;
+
+ // CLI launch history
+    cliHistory: CliHistoryEntry[];
+
+ // Per-provider user config (public setting values)
+    providerSettings: Record<string, Record<string, any>>;
+
+ // Per-IDE extension config (per-IDE on/off control)
+    ideSettings: Record<string, {
+        extensions?: Record<string, { enabled: boolean }>;
+    }>;
+}
+
+export interface CliHistoryEntry {
+    cliType: string;
+    dir: string;
+    cliArgs?: string[];
+    timestamp: number;
+    label?: string;
+}
+
+const DEFAULT_CONFIG: ADHDevConfig = {
+    serverUrl: 'https://api.adhf.dev',
+    apiToken: null,
+    connectionToken: null,
+    selectedIde: null,
+    configuredIdes: [],
+    installedExtensions: [],
+    autoConnect: true,
+    notifications: true,
+    userEmail: null,
+    userName: null,
+    setupCompleted: false,
+    setupDate: null,
+    configuredCLIs: [],
+    enabledIdes: [],
+    recentCliWorkspaces: [],
+    machineNickname: null,
+    cliHistory: [],
+    providerSettings: {},
+    ideSettings: {},
+};
+
+/**
+ * Get the config directory path
+ */
+export function getConfigDir(): string {
+    const dir = join(homedir(), '.adhdev');
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+
+/**
+ * Get the config file path
+ */
+function getConfigPath(): string {
+    return join(getConfigDir(), 'config.json');
+}
+
+/**
+ * Load configuration from disk
+ */
+export function loadConfig(): ADHDevConfig {
+    const configPath = getConfigPath();
+
+    if (!existsSync(configPath)) {
+        return { ...DEFAULT_CONFIG };
+    }
+
+    try {
+        const raw = readFileSync(configPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return { ...DEFAULT_CONFIG, ...parsed };
+    } catch {
+        return { ...DEFAULT_CONFIG };
+    }
+}
+
+/**
+ * Save configuration to disk
+ */
+export function saveConfig(config: ADHDevConfig): void {
+    const configPath = getConfigPath();
+    const dir = getConfigDir();
+
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+
+    writeFileSync(configPath, JSON.stringify(config, null, 2), { encoding: 'utf-8', mode: 0o600 });
+    try { chmodSync(configPath, 0o600); } catch { /* Windows etc. not supported */ }
+}
+
+/**
+ * Update specific config fields
+ */
+export function updateConfig(updates: Partial<ADHDevConfig>): ADHDevConfig {
+    const config = loadConfig();
+    const updated = { ...config, ...updates };
+    saveConfig(updated);
+    return updated;
+}
+
+/**
+ * Mark setup as completed
+ */
+export function markSetupComplete(
+    ideId: string | string[],
+    extensions: string[]
+): ADHDevConfig {
+    const ideIds = Array.isArray(ideId) ? ideId : [ideId];
+    return updateConfig({
+        selectedIde: ideIds[0],
+        configuredIdes: ideIds,
+        installedExtensions: extensions,
+        setupCompleted: true,
+        setupDate: new Date().toISOString(),
+    });
+}
+
+/**
+ * Check if setup has been completed before
+ */
+export function isSetupComplete(): boolean {
+    const config = loadConfig();
+    return config.setupCompleted;
+}
+
+/**
+ * Reset configuration
+ */
+export function resetConfig(): void {
+    saveConfig({ ...DEFAULT_CONFIG });
+}
+
+/**
+ * Generate a connection token for server authentication
+ */
+export function generateConnectionToken(): string {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let token = 'db_';
+    for (let i = 0; i < 32; i++) {
+        token += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return token;
+}
+/**
+ * Add CLI launch to history (max 20, dedup by cliType+dir+args)
+ */
+export function addCliHistory(entry: Omit<CliHistoryEntry, 'timestamp'>): void {
+    const config = loadConfig();
+    const history = config.cliHistory || [];
+    const argsKey = (entry.cliArgs || []).join(' ');
+    
+ // Remove duplicate (same cliType + dir + args)
+    const filtered = history.filter(h => {
+        const hArgsKey = (h.cliArgs || []).join(' ');
+        return !(h.cliType === entry.cliType && h.dir === entry.dir && hArgsKey === argsKey);
+    });
+    
+ // Add to front
+    filtered.unshift({
+        ...entry,
+        timestamp: Date.now(),
+        label: entry.label || `${entry.cliType} · ${entry.dir.split('/').filter(Boolean).pop() || 'root'}${argsKey ? ` (${argsKey})` : ''}`,
+    });
+    
+ // Keep max 20
+    config.cliHistory = filtered.slice(0, 20);
+    saveConfig(config);
+}