@adhdev/daemon-core 0.7.40 → 0.7.42

package/src/config/config.ts

@@ -1,7 +1,7 @@
 /**
  * ADHDev Launcher — Configuration
- * 
- * Manages launcher config, server connection tokens, and user preferences.
+ *
+ * Manages launcher config, machine auth, and user preferences.
  */
 
 import { homedir } from 'os';
@@ -16,8 +16,6 @@ export type { RecentActivityEntry } from './recent-activity.js';
 export interface ADHDevConfig {
  // Server connection
     serverUrl: string;
-    apiToken: string | null;
-    connectionToken: string | null;
 
  // Selected IDE (primary)
     selectedIde: string | null;
@@ -28,16 +26,6 @@ export interface ADHDevConfig {
  // Installed extensions
     installedExtensions: string[];
 
- // User preferences
-    autoConnect: boolean;
-    /**
-     * @deprecated Not read at runtime. Notification preferences are now managed by:
-     * - Web UI layer: useNotificationPrefs (localStorage)
-     * - Daemon layer: per-provider settings (approvalAlert, longGeneratingAlert)
-     * Kept for backward config compat — will be removed in v0.7+.
-     */
-    notifications: boolean;
-
  // Auth
     userEmail: string | null;
     userName: string | null;
@@ -46,9 +34,6 @@ export interface ADHDevConfig {
     setupCompleted: boolean;
     setupDate: string | null;
 
- // Configured CLI agents
-    configuredCLIs: string[];
-
  // Daemon: which IDEs to connect (empty = all)
     enabledIdes: string[];
 
@@ -70,20 +55,15 @@ export interface ADHDevConfig {
     /**
      * Stable local machine ID (prefix: `mach_`) — generated locally on first run.
      * Used as daemon instance key (`daemon_<machineId>`) and in status reports.
-     * NOT the same as the server-side D1 `machines.id` — see `registeredMachineId`.
      */
     machineId?: string;
 
- // Machine secret for server auth (replaces connectionToken)
+ // Machine secret for server auth
     machineSecret?: string | null;
 
     /**
      * Server-side D1 `machines.id` — the row ID assigned when daemon registers via
-     * `POST /cli/complete`. Corresponds to `machineId` in server DO context
-     * (`DaemonConnection.machineId`, `StatusContext.machineId`).
-     *
-     * Naming differs from server-side `machineId` to avoid confusion with the local
-     * `config.machineId` (mach_ prefix) which is a different value.
+     * `POST /cli/complete`. Used as fallback for machine lookup on re-auth.
      *
      * @deprecated Legacy bridge field — will be removed after 2026-04-06.
      * Modern auth flow uses `machineSecret` (adm_) to identify machines.
@@ -108,18 +88,13 @@ export interface ADHDevConfig {
 
 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: [],
     workspaces: [],
     defaultWorkspaceId: null,
@@ -137,6 +112,68 @@ const DEFAULT_CONFIG: ADHDevConfig = {
 
 const MACHINE_ID_PREFIX = 'mach_';
 
+function isPlainObject(value: unknown): value is Record<string, any> {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function asStringArray(value: unknown): string[] {
+    if (!Array.isArray(value)) return [];
+    return value.filter((item): item is string => typeof item === 'string');
+}
+
+function asNullableString(value: unknown): string | null {
+    return typeof value === 'string' ? value : null;
+}
+
+function asOptionalString(value: unknown): string | undefined {
+    return typeof value === 'string' && value.trim() ? value : undefined;
+}
+
+function asBoolean(value: unknown, fallback: boolean): boolean {
+    return typeof value === 'boolean' ? value : fallback;
+}
+
+function normalizeConfig(raw: unknown): ADHDevConfig & { activeWorkspaceId?: string | null } {
+    const parsed = isPlainObject(raw) ? raw : {};
+    const legacySessionReads = isPlainObject(parsed.recentSessionReads) ? parsed.recentSessionReads : {};
+    const sessionReads = isPlainObject(parsed.sessionReads) ? parsed.sessionReads : {};
+    const mergedSessionReads = Object.fromEntries(
+        Object.entries({ ...legacySessionReads, ...sessionReads })
+            .filter(([, value]) => typeof value === 'number' && Number.isFinite(value))
+    );
+    const sessionReadMarkers = Object.fromEntries(
+        Object.entries(isPlainObject(parsed.sessionReadMarkers) ? parsed.sessionReadMarkers : {})
+            .filter(([, value]) => typeof value === 'string')
+    );
+
+    return {
+        serverUrl: typeof parsed.serverUrl === 'string' && parsed.serverUrl.trim()
+            ? parsed.serverUrl
+            : DEFAULT_CONFIG.serverUrl,
+        selectedIde: asNullableString(parsed.selectedIde),
+        configuredIdes: asStringArray(parsed.configuredIdes),
+        installedExtensions: asStringArray(parsed.installedExtensions),
+        userEmail: asNullableString(parsed.userEmail),
+        userName: asNullableString(parsed.userName),
+        setupCompleted: asBoolean(parsed.setupCompleted, DEFAULT_CONFIG.setupCompleted),
+        setupDate: asNullableString(parsed.setupDate),
+        enabledIdes: asStringArray(parsed.enabledIdes),
+        workspaces: Array.isArray(parsed.workspaces) ? parsed.workspaces as WorkspaceEntry[] : [],
+        defaultWorkspaceId: asNullableString(parsed.defaultWorkspaceId) ?? asNullableString(parsed.activeWorkspaceId),
+        recentActivity: Array.isArray(parsed.recentActivity) ? parsed.recentActivity as RecentActivityEntry[] : [],
+        sessionReads: mergedSessionReads,
+        sessionReadMarkers,
+        machineNickname: asNullableString(parsed.machineNickname),
+        machineId: asOptionalString(parsed.machineId),
+        machineSecret: parsed.machineSecret === null ? null : asOptionalString(parsed.machineSecret),
+        registeredMachineId: asOptionalString(parsed.registeredMachineId),
+        providerSettings: isPlainObject(parsed.providerSettings) ? parsed.providerSettings : {},
+        ideSettings: isPlainObject(parsed.ideSettings) ? parsed.ideSettings : {},
+        disableUpstream: asBoolean(parsed.disableUpstream, DEFAULT_CONFIG.disableUpstream ?? false),
+        providerDir: asOptionalString(parsed.providerDir),
+    };
+}
+
 export function generateMachineId(): string {
     return `${MACHINE_ID_PREFIX}${randomUUID().replace(/-/g, '')}`;
 }
@@ -201,14 +238,10 @@ export function loadConfig(): ADHDevConfig {
     try {
         const raw = readFileSync(configPath, 'utf-8');
         const parsed = JSON.parse(raw);
-        const merged = { ...DEFAULT_CONFIG, ...parsed } as ADHDevConfig & { activeWorkspaceId?: string | null };
-        if (merged.defaultWorkspaceId == null && merged.activeWorkspaceId != null) {
-            (merged as ADHDevConfig).defaultWorkspaceId = merged.activeWorkspaceId;
-        }
-        delete (merged as any).activeWorkspaceId;
-        const ensured = ensureMachineId(merged);
+        const normalizedInput = normalizeConfig(parsed);
+        const ensured = ensureMachineId(normalizedInput);
         const normalized = ensured.config as ADHDevConfig & { activeWorkspaceId?: string | null };
-        if (ensured.changed) {
+        if (ensured.changed || JSON.stringify(parsed) !== JSON.stringify(normalized)) {
             try {
                 saveConfig(normalized);
             } catch { /* ignore */ }
@@ -226,12 +259,13 @@ export function loadConfig(): ADHDevConfig {
 export function saveConfig(config: ADHDevConfig): void {
     const configPath = getConfigPath();
     const dir = getConfigDir();
+    const normalized = normalizeConfig(config);
 
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true, mode: 0o700 });
     }
 
-    writeFileSync(configPath, JSON.stringify(config, null, 2), { encoding: 'utf-8', mode: 0o600 });
+    writeFileSync(configPath, JSON.stringify(normalized, null, 2), { encoding: 'utf-8', mode: 0o600 });
     try { chmodSync(configPath, 0o600); } catch { /* Windows etc. not supported */ }
 }
 
@@ -276,15 +310,3 @@ export function isSetupComplete(): boolean {
 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;
-}

package/src/config/workspaces.d.ts

@@ -17,10 +17,7 @@ export declare function validateWorkspacePath(absPath: string): {
 };
 /** Default workspace label from path */
 export declare function defaultWorkspaceLabel(absPath: string): string;
-/**
- * Ensure config.workspaces exists; seed from recentCliWorkspaces once (same paths).
- */
-export declare function migrateWorkspacesFromRecent(config: ADHDevConfig): ADHDevConfig;
+
 export declare function getDefaultWorkspacePath(config: ADHDevConfig): string | null;
 export declare function getWorkspaceState(config: ADHDevConfig): {
     workspaces: WorkspaceEntry[];

package/src/providers/cli-provider-instance.ts

@@ -33,6 +33,8 @@ export class CliProviderInstance implements ProviderInstance {
     private historyWriter: ChatHistoryWriter;
     readonly instanceId: string;
 
+    private presentationMode: 'terminal' | 'chat';
+
     constructor(
         private provider: ProviderModule,
         private workingDir: string,
@@ -42,6 +44,7 @@ export class CliProviderInstance implements ProviderInstance {
     ) {
         this.type = provider.type;
         this.instanceId = instanceId || crypto.randomUUID();
+        this.presentationMode = 'terminal';
         this.adapter = new ProviderCliAdapter(provider as any as CliProviderModule, workingDir, cliArgs, transportFactory);
         this.monitor = new StatusMonitor();
         this.historyWriter = new ChatHistoryWriter();
@@ -84,6 +87,7 @@ export class CliProviderInstance implements ProviderInstance {
 
     getState(): ProviderState {
         const adapterStatus = this.adapter.getStatus();
+        const parsedStatus = this.adapter.getScriptParsedStatus?.() || null;
         const runtime = this.adapter.getRuntimeMetadata();
 
         const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
@@ -102,13 +106,13 @@ export class CliProviderInstance implements ProviderInstance {
             name: this.provider.name,
             category: 'cli',
             status: adapterStatus.status,
-            mode: 'terminal',
+            mode: this.presentationMode,
             activeChat: {
                 id: `${this.type}_${this.workingDir}`,
-                title: `${this.provider.name} · ${dirName}`,
-                status: adapterStatus.status,
-                messages: [],
-                activeModal: adapterStatus.activeModal,
+                title: parsedStatus?.title || `${this.provider.name} · ${dirName}`,
+                status: parsedStatus?.status || adapterStatus.status,
+                messages: Array.isArray(parsedStatus?.messages) ? parsedStatus.messages : [],
+                activeModal: parsedStatus?.activeModal ?? adapterStatus.activeModal,
                 terminalHistory: adapterStatus.terminalHistory,
                 inputContent: '',
             },
@@ -131,6 +135,15 @@ export class CliProviderInstance implements ProviderInstance {
         };
     }
 
+    setPresentationMode(mode: 'terminal' | 'chat'): void {
+        if (this.presentationMode === mode) return;
+        this.presentationMode = mode;
+    }
+
+    getPresentationMode(): 'terminal' | 'chat' {
+        return this.presentationMode;
+    }
+
     onEvent(event: string, data?: any): void {
         if (event === 'send_message' && data?.text) {
             void this.adapter.sendMessage(data.text).catch((e: any) => {

package/src/providers/contracts.ts

@@ -608,4 +608,3 @@ export interface ProviderControlDef {
  /** Hide this control when condition not met */
   hidden?: boolean;
 }
-

package/src/providers/extension-provider-instance.ts

@@ -111,6 +111,8 @@ export class ExtensionProviderInstance implements ProviderInstance {
                 this.detectTransition(newStatus, data);
                 this.currentStatus = newStatus;
             }
+        } else if (event === 'stream_reset') {
+            this.resetStreamState();
         } else if (event === 'extension_connected') {
             this.ideType = data?.ideType || '';
  // Maintain instanceId UUID — do not overwrite
@@ -208,4 +210,29 @@ export class ExtensionProviderInstance implements ProviderInstance {
             : this.chatTitle;
         return title || this.agentName || this.provider.name;
     }
+
+    private resetStreamState(): void {
+        if (this.currentStatus !== 'idle') {
+            this.detectTransition('idle', {
+                title: this.chatTitle,
+                agentName: this.agentName,
+                extensionId: this.extensionId,
+                messages: this.messages,
+            });
+        }
+        this.agentStreams = [];
+        this.messages = [];
+        this.activeModal = null;
+        this.currentModel = '';
+        this.currentMode = '';
+        this.controlValues = {};
+        this.currentStatus = 'idle';
+        this.chatId = null;
+        this.chatTitle = null;
+        this.agentName = '';
+        this.extensionId = '';
+        this.lastAgentStatus = 'idle';
+        this.generatingStartedAt = 0;
+        this.monitor.reset();
+    }
 }

package/src/providers/ide-provider-instance.ts

@@ -140,12 +140,24 @@ export class IdeProviderInstance implements ProviderInstance {
         } else if (event === 'cdp_disconnected') {
             this.cachedChat = null;
             this.currentStatus = 'idle';
+            for (const ext of this.extensions.values()) {
+                ext.onEvent('stream_reset');
+            }
         } else if (event === 'stream_update') {
  // Forward to Extension
             const extType = data?.extensionType;
             if (extType && this.extensions.has(extType)) {
                 this.extensions.get(extType)!.onEvent('stream_update', data);
             }
+        } else if (event === 'stream_reset') {
+            const extType = data?.extensionType;
+            if (extType && this.extensions.has(extType)) {
+                this.extensions.get(extType)!.onEvent('stream_reset');
+            }
+        } else if (event === 'stream_reset_all') {
+            for (const ext of this.extensions.values()) {
+                ext.onEvent('stream_reset');
+            }
         }
     }
 

package/src/shared-types.ts

@@ -102,6 +102,8 @@ export interface SessionEntry {
     runtimeKey?: string;
     runtimeDisplayName?: string;
     runtimeWorkspaceLabel?: string;
+    /** CLI only: active presentation mode */
+    mode?: 'terminal' | 'chat';
     runtimeWriteOwner?: RuntimeWriteOwner | null;
     runtimeAttachedClients?: RuntimeAttachedClient[];
     resume?: ProviderResumeCapability;

package/src/status/builders.ts

@@ -167,6 +167,12 @@ const PTY_SESSION_CAPABILITIES: SessionCapability[] = [
     'resize_terminal',
 ];
 
+const CLI_CHAT_SESSION_CAPABILITIES: SessionCapability[] = [
+    'read_chat',
+    'send_message',
+    'resolve_action',
+];
+
 const ACP_SESSION_CAPABILITIES: SessionCapability[] = [
     'read_chat',
     'send_message',
@@ -265,9 +271,10 @@ function buildCliSession(state: CliProviderState): SessionEntry {
         runtimeWorkspaceLabel: state.runtime?.workspaceLabel,
         runtimeWriteOwner: state.runtime?.writeOwner || null,
         runtimeAttachedClients: state.runtime?.attachedClients || [],
+        mode: state.mode,
         resume: state.resume,
         activeChat,
-        capabilities: PTY_SESSION_CAPABILITIES,
+        capabilities: state.mode === 'terminal' ? PTY_SESSION_CAPABILITIES : CLI_CHAT_SESSION_CAPABILITIES,
         controlValues: state.controlValues,
         providerControls: buildFallbackControls(
             state.providerControls

package/src/status/normalize.ts

@@ -20,6 +20,78 @@ const WORKING_STATUSES = new Set([
     'active',
 ]);
 
+// Status snapshots are sent over P2P every 5s, so keep only a recent live window here.
+// Older history is fetched on demand via `chat_history`, and CLI terminals stream via runtime events.
+const STATUS_ACTIVE_CHAT_MESSAGE_LIMIT = 60;
+const STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT = 96 * 1024;
+const STATUS_ACTIVE_CHAT_STRING_LIMIT = 4 * 1024;
+const STATUS_ACTIVE_CHAT_FALLBACK_STRING_LIMIT = 1024;
+const STATUS_TERMINAL_HISTORY_LIMIT = 8 * 1024;
+const STATUS_INPUT_CONTENT_LIMIT = 2 * 1024;
+const STATUS_MODAL_MESSAGE_LIMIT = 2 * 1024;
+const STATUS_MODAL_BUTTON_LIMIT = 120;
+
+function truncateString(value: string, maxChars: number): string {
+    if (value.length <= maxChars) return value;
+    if (maxChars <= 12) return value.slice(0, Math.max(0, maxChars));
+    return `${value.slice(0, maxChars - 12)}...[truncated]`;
+}
+
+function truncateStringTail(value: string, maxChars: number): string {
+    if (value.length <= maxChars) return value;
+    if (maxChars <= 12) return value.slice(value.length - Math.max(0, maxChars));
+    return `...[truncated]${value.slice(value.length - (maxChars - 12))}`;
+}
+
+function trimStructuredStrings(value: unknown, maxChars: number): unknown {
+    if (typeof value === 'string') return truncateString(value, maxChars);
+    if (Array.isArray(value)) return value.map((item) => trimStructuredStrings(item, maxChars));
+    if (!value || typeof value !== 'object') return value;
+    return Object.fromEntries(
+        Object.entries(value).map(([key, nested]) => [key, trimStructuredStrings(nested, maxChars)]),
+    );
+}
+
+function estimateBytes(value: unknown): number {
+    try {
+        return JSON.stringify(value).length;
+    } catch {
+        return String(value ?? '').length;
+    }
+}
+
+function trimMessageForStatus(message: unknown, stringLimit: number): unknown {
+    if (!message || typeof message !== 'object') return message;
+    return trimStructuredStrings(message, stringLimit);
+}
+
+function trimMessagesForStatus(messages: unknown[] | null | undefined): unknown[] {
+    if (!Array.isArray(messages) || messages.length === 0) return [];
+
+    const recent = messages.slice(-STATUS_ACTIVE_CHAT_MESSAGE_LIMIT);
+    const kept: unknown[] = [];
+    let totalBytes = 0;
+
+    for (let i = recent.length - 1; i >= 0; i -= 1) {
+        let normalized = trimMessageForStatus(recent[i], STATUS_ACTIVE_CHAT_STRING_LIMIT);
+        let size = estimateBytes(normalized);
+
+        if (size > STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT) {
+            normalized = trimMessageForStatus(recent[i], STATUS_ACTIVE_CHAT_FALLBACK_STRING_LIMIT);
+            size = estimateBytes(normalized);
+        }
+
+        if (kept.length > 0 && (totalBytes + size) > STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT) {
+            continue;
+        }
+
+        kept.push(normalized);
+        totalBytes += size;
+    }
+
+    return kept.reverse();
+}
+
 function hasApprovalButtons(activeModal?: { buttons?: unknown[] | null } | null): boolean {
     return (activeModal?.buttons?.length ?? 0) > 0;
 }
@@ -60,5 +132,18 @@ export function normalizeActiveChatData<T extends ActiveChatData | null | undefi
     return {
         ...activeChat,
         status: normalizeManagedStatus(activeChat.status, { activeModal: activeChat.activeModal }),
+        messages: trimMessagesForStatus(activeChat.messages) as T extends { messages: infer M } ? M : never,
+        activeModal: activeChat.activeModal ? {
+            message: truncateString(activeChat.activeModal.message || '', STATUS_MODAL_MESSAGE_LIMIT),
+            buttons: (activeChat.activeModal.buttons || []).map((button) =>
+                truncateString(String(button || ''), STATUS_MODAL_BUTTON_LIMIT)
+            ),
+        } : activeChat.activeModal,
+        terminalHistory: activeChat.terminalHistory
+            ? truncateStringTail(activeChat.terminalHistory, STATUS_TERMINAL_HISTORY_LIMIT)
+            : activeChat.terminalHistory,
+        inputContent: activeChat.inputContent
+            ? truncateString(activeChat.inputContent, STATUS_INPUT_CONTENT_LIMIT)
+            : activeChat.inputContent,
     } as T;
 }

package/src/status/reporter.ts

@@ -113,6 +113,26 @@ export class DaemonStatusReporter {
         return new Date().toISOString().slice(11, 23); // HH:mm:ss.SSS
     }
 
+    private summarizeLargePayloadSessions(payload: Record<string, any>): string {
+        const sessions = Array.isArray(payload.sessions) ? payload.sessions : [];
+        return sessions
+            .map((session: any) => ({
+                id: String(session?.id || ''),
+                providerType: String(session?.providerType || ''),
+                bytes: (() => {
+                    try {
+                        return JSON.stringify(session).length;
+                    } catch {
+                        return 0;
+                    }
+                })(),
+            }))
+            .sort((a, b) => b.bytes - a.bytes)
+            .slice(0, 3)
+            .map((session) => `${session.providerType || 'unknown'}:${session.id}=${session.bytes}b`)
+            .join(', ');
+    }
+
     async sendUnifiedStatusReport(opts?: { p2pOnly?: boolean }): Promise<void> {
         const { serverConn, p2p } = this.deps;
         if (!serverConn?.isConnected()) return;
@@ -179,10 +199,17 @@ export class DaemonStatusReporter {
             connectedExtensions: [],
         };
 
- // ═══ P2P transmit ═══
+// ═══ P2P transmit ═══
+        const payloadBytes = JSON.stringify(payload).length;
         const p2pSent = this.sendP2PPayload(payload);
         if (p2pSent) {
-            LOG.debug('P2P', `sent (${JSON.stringify(payload).length} bytes)`);
+            LOG.debug('P2P', `sent (${payloadBytes} bytes)`);
+            if (payloadBytes > 256 * 1024) {
+                LOG.warn(
+                    'P2P',
+                    `large status payload (${payloadBytes} bytes) top sessions: ${this.summarizeLargePayloadSessions(payload) || 'n/a'}`,
+                );
+            }
         }
 
  // ═══ Server transmit (minimal routing meta only) ═══
@@ -215,6 +242,8 @@ export class DaemonStatusReporter {
             })),
             p2p: payload.p2p,
             timestamp: now,
+            detectedIdes: payload.detectedIdes,
+            availableProviders: payload.availableProviders,
         };
         serverConn.sendMessage('status_report', wsPayload);
         LOG.debug('Server', `sent status_report (${JSON.stringify(wsPayload).length} bytes)`);