@adhdev/daemon-core 0.8.33 → 0.8.35

package/src/shared-types.d.ts

@@ -36,6 +36,8 @@ export interface AgentSessionStream {
 export type SessionTransport = 'cdp-page' | 'cdp-webview' | 'pty' | 'acp';
 export type SessionKind = 'workspace' | 'agent';
 export type SessionCapability = 'read_chat' | 'send_message' | 'new_session' | 'list_sessions' | 'switch_session' | 'resolve_action' | 'terminal_io' | 'resize_terminal' | 'change_model' | 'set_mode' | 'set_thought_level';
+import type { RuntimeWriteOwner, RuntimeAttachedClient, SessionStatus } from './shared-types-extra.js';
+export type { RuntimeWriteOwner, RuntimeAttachedClient, SessionStatus } from './shared-types-extra.js';
 export interface SessionEntry {
     id: string;
     parentId: string | null;
@@ -44,21 +46,16 @@ export interface SessionEntry {
     providerSessionId?: string;
     kind: SessionKind;
     transport: SessionTransport;
-    status: 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting' | 'panel_hidden' | 'not_monitored' | 'disconnected';
+    status: SessionStatus;
     title: string;
     workspace: string | null;
     runtimeKey?: string;
     runtimeDisplayName?: string;
     runtimeWorkspaceLabel?: string;
-    runtimeWriteOwner?: {
-        clientId: string;
-        ownerType: 'agent' | 'user';
-    } | null;
-    runtimeAttachedClients?: {
-        clientId: string;
-        type: 'daemon' | 'web' | 'local-terminal';
-        readOnly: boolean;
-    }[];
+    /** CLI only: active presentation mode */
+    mode?: 'terminal' | 'chat';
+    runtimeWriteOwner?: RuntimeWriteOwner | null;
+    runtimeAttachedClients?: RuntimeAttachedClient[];
     resume?: ProviderResumeCapability;
     activeChat: _ActiveChatData | null;
     capabilities: SessionCapability[];
@@ -68,10 +65,36 @@ export interface SessionEntry {
     currentAutoApprove?: string;
     acpConfigOptions?: AcpConfigOption[];
     acpModes?: AcpMode[];
+    /** Dynamic control current values (generic key-value) */
     controlValues?: Record<string, string | number | boolean>;
+    /** Provider-declared controls schema (transmitted once, cached by frontend) */
     providerControls?: ProviderControlSchema[];
     errorMessage?: string;
     errorReason?: _ProviderErrorReason;
+    lastUpdated?: number;
+    unread?: boolean;
+    lastSeenAt?: number;
+    inboxBucket?: RecentSessionBucket;
+    surfaceHidden?: boolean;
+}
+/**
+ * Compact session metadata stored in UserSessionDO and reused by server-side
+ * status/convenience APIs. This intentionally excludes rich UI-only fields.
+ */
+export interface CompactSessionEntry {
+    id: string;
+    parentId: string | null;
+    providerType: string;
+    providerName: string;
+    kind: SessionKind;
+    transport: SessionTransport;
+    status: SessionStatus;
+    title: string;
+    workspace: string | null;
+    cdpConnected?: boolean;
+    currentModel?: string;
+    currentPlan?: string;
+    currentAutoApprove?: string;
 }
 /** Available provider information */
 export interface AvailableProviderInfo {
@@ -80,6 +103,8 @@ export interface AvailableProviderInfo {
     category: 'ide' | 'extension' | 'cli' | 'acp';
     displayName: string;
     icon: string;
+    installed?: boolean;
+    detectedPath?: string | null;
 }
 /** ACP config option (model/mode/thought_level selection) */
 export interface AcpConfigOption {
@@ -99,24 +124,39 @@ export interface AcpMode {
     name: string;
     description?: string;
 }
-/** Provider control schema (daemon → frontend) */
+/** Provider control schema transmitted to frontend */
 export interface ProviderControlSchema {
     id: string;
-    type: 'select' | 'toggle' | 'cycle' | 'slider' | 'action';
+    type: 'select' | 'toggle' | 'cycle' | 'slider' | 'action' | 'display';
     label: string;
     icon?: string;
     placement: 'bar' | 'header' | 'menu';
-    options?: { value: string; label: string; description?: string; group?: string }[];
+    /** Static options (for select/cycle) */
+    options?: {
+        value: string;
+        label: string;
+        description?: string;
+        group?: string;
+    }[];
+    /** Dynamic options — frontend should call listScript to load */
     dynamic?: boolean;
+    /** Script name to list options */
     listScript?: string;
+    /** Script name to change value (value-based controls) */
     setScript?: string;
+    /** Field name in readChat result for current value */
     readFrom?: string;
+    /** Default value */
     defaultValue?: string | number | boolean;
+    /** Script name to invoke (action type) */
     invokeScript?: string;
+    /** How to display action result */
     resultDisplay?: 'toast' | 'inline' | 'none';
+    /** Slider range */
     min?: number;
     max?: number;
     step?: number;
+    /** Sort order */
     order?: number;
 }
 /** Machine hardware/OS info (reported by daemon, displayed by web) */
@@ -141,13 +181,9 @@ export interface DetectedIdeInfo {
     running: boolean;
     path?: string;
 }
-/** Workspace recent activity */
-export interface WorkspaceActivity {
-    path: string;
-    lastUsedAt: number;
-    kind?: string;
-    agentType?: string;
-}
+export type { RecentSessionBucket, TerminalBackendStatus } from './shared-types-extra.js';
+import type { RecentSessionBucket } from './shared-types-extra.js';
+import type { TerminalBackendStatus } from './shared-types-extra.js';
 export interface RecentLaunchEntry {
     id: string;
     providerType: string;
@@ -159,8 +195,27 @@ export interface RecentLaunchEntry {
     currentModel?: string;
     lastLaunchedAt: number;
 }
+/** Compact machine payload broadcast by UserSessionDO to cloud dashboards. */
+export interface CompactDaemonEntry {
+    id: string;
+    type?: string;
+    machineId?: string;
+    platform?: string;
+    hostname?: string;
+    nickname?: string;
+    p2p?: StatusReportPayload['p2p'];
+    cdpConnected?: boolean;
+    timestamp?: number;
+    version?: string;
+    serverVersion?: string;
+    versionMismatch?: boolean;
+    terminalBackend?: TerminalBackendStatus;
+    detectedIdes?: DetectedIdeInfo[];
+    availableProviders?: AvailableProviderInfo[];
+    sessions?: CompactSessionEntry[];
+}
 export interface StatusReportPayload {
-    /** Daemon instance ID */
+    /** Unique daemon instance identifier */
     instanceId: string;
     /** Daemon version */
     version: string;
@@ -188,6 +243,8 @@ export interface StatusReportPayload {
     defaultWorkspaceId?: string | null;
     defaultWorkspacePath?: string | null;
     terminalSizingMode?: 'measured' | 'fit';
-    workspaceActivity?: WorkspaceActivity[];
     recentLaunches?: RecentLaunchEntry[];
+    terminalBackend?: TerminalBackendStatus;
+    /** Available providers (present in StatusSnapshot, optional in raw payload) */
+    availableProviders?: AvailableProviderInfo[];
 }

package/src/shared-types.ts

@@ -129,6 +129,26 @@ export interface SessionEntry {
     surfaceHidden?: boolean;
 }
 
+/**
+ * Compact session metadata stored in UserSessionDO and reused by server-side
+ * status/convenience APIs. This intentionally excludes rich UI-only fields.
+ */
+export interface CompactSessionEntry {
+    id: string;
+    parentId: string | null;
+    providerType: string;
+    providerName: string;
+    kind: SessionKind;
+    transport: SessionTransport;
+    status: SessionStatus;
+    title: string;
+    workspace: string | null;
+    cdpConnected?: boolean;
+    currentModel?: string;
+    currentPlan?: string;
+    currentAutoApprove?: string;
+}
+
 /** Available provider information */
 export interface AvailableProviderInfo {
     type: string;
@@ -231,6 +251,26 @@ export interface RecentLaunchEntry {
     lastLaunchedAt: number;
 }
 
+/** Compact machine payload broadcast by UserSessionDO to cloud dashboards. */
+export interface CompactDaemonEntry {
+    id: string;
+    type?: string;
+    machineId?: string;
+    platform?: string;
+    hostname?: string;
+    nickname?: string;
+    p2p?: StatusReportPayload['p2p'];
+    cdpConnected?: boolean;
+    timestamp?: number;
+    version?: string;
+    serverVersion?: string;
+    versionMismatch?: boolean;
+    terminalBackend?: TerminalBackendStatus;
+    detectedIdes?: DetectedIdeInfo[];
+    availableProviders?: AvailableProviderInfo[];
+    sessions?: CompactSessionEntry[];
+}
+
 // ─── Status Report Payload (daemon → server) ────────────────────────
 // Full payload shape sent via WebSocket status_report
 

package/src/status/builders.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Status Builders — shared conversion functions for ProviderState → ManagedEntry
+ *
+ * Used by:
+ *   - daemon-standalone (StandaloneServer.getStatus)
+ *   - DaemonStatusReporter
+ *
+ * Consolidates ProviderState→ManagedEntry mapping logic.
+ */
+import type { DaemonCdpManager } from '../cdp/manager.js';
+import type { SessionEntry } from '../shared-types.js';
+import type { ProviderState } from '../providers/provider-instance.js';
+/**
+ * Find a CDP manager by key, with prefix matching for multi-window support.
+ *
+ * Lookup order:
+ *   1. Exact match: cdpManagers.get(key)
+ *   2. Prefix match: key starts with `${ideType}_` (multi-window: "cursor_remote_vs")
+ *   3. null
+ *
+ * This replaces raw `cdpManagers.get(ideType)` calls that broke when
+ * multi-window keys like "cursor_remote_vs" were used.
+ */
+export declare function findCdpManager(cdpManagers: Map<string, DaemonCdpManager>, key: string): DaemonCdpManager | null;
+/**
+ * Check if any CDP manager matches the given key (exact or prefix).
+ */
+export declare function hasCdpManager(cdpManagers: Map<string, DaemonCdpManager>, key: string): boolean;
+/**
+ * Check if any CDP manager matching the key is connected.
+ */
+export declare function isCdpConnected(cdpManagers: Map<string, DaemonCdpManager>, key: string): boolean;
+export declare function buildSessionEntries(allStates: ProviderState[], cdpManagers: Map<string, DaemonCdpManager>): SessionEntry[];

package/src/status/reporter.d.ts

@@ -0,0 +1,69 @@
+/**
+ * DaemonStatusReporter — status collect & transmit (StatusReport / P2P / StatusEvent)
+ *
+ * Collect status from ProviderInstanceManager → assemble payload → transmit
+ * Each Instance manages its own status/transition. This module only assembles + transmits.
+ */
+import type { DaemonCdpManager } from '../cdp/manager.js';
+import type { ProviderState } from '../providers/provider-instance.js';
+export interface StatusReporterDeps {
+    serverConn: {
+        isConnected(): boolean;
+        sendMessage(type: string, data: any): void;
+        getUserPlan(): string;
+    } | null;
+    cdpManagers: Map<string, DaemonCdpManager>;
+    p2p: {
+        isConnected: boolean;
+        isAvailable: boolean;
+        connectionState: string;
+        connectedPeerCount: number;
+        screenshotActive: boolean;
+        sendStatus(data: any): void;
+    } | null;
+    providerLoader: {
+        resolve(type: string): any;
+        getAll(): any[];
+    };
+    detectedIdes: any[];
+    instanceId: string;
+    daemonVersion?: string;
+    instanceManager: {
+        collectAllStates(): ProviderState[];
+        collectStatesByCategory(cat: string): ProviderState[];
+    };
+    getScreenshotUsage?: () => {
+        dailyUsedMinutes: number;
+        dailyBudgetMinutes: number;
+        budgetExhausted: boolean;
+    } | null;
+}
+export declare class DaemonStatusReporter {
+    private deps;
+    private log;
+    private lastStatusSentAt;
+    private statusPendingThrottle;
+    private lastP2PStatusHash;
+    private lastStatusSummary;
+    private statusTimer;
+    private p2pTimer;
+    constructor(deps: StatusReporterDeps, opts?: {
+        logFn?: (msg: string) => void;
+    });
+    startReporting(): void;
+    stopReporting(): void;
+    onStatusChange(): void;
+    throttledReport(): void;
+    emitStatusEvent(event: Record<string, unknown>): void;
+    removeAgentTracking(_key: string): void;
+    updateAgentStreams(_ideType: string, _streams: any[]): void;
+    /** Reset P2P dedup hash — forces next send to transmit even if content unchanged */
+    resetP2PHash(): void;
+    private ts;
+    private summarizeLargePayloadSessions;
+    sendUnifiedStatusReport(opts?: {
+        p2pOnly?: boolean;
+    }): Promise<void>;
+    private sendP2PPayload;
+    private simpleHash;
+}

package/src/status/reporter.ts

@@ -38,6 +38,7 @@ export class DaemonStatusReporter {
     private lastStatusSentAt = 0;
     private statusPendingThrottle = false;
     private lastP2PStatusHash = '';
+    private lastServerStatusHash = '';
     private lastStatusSummary = '';
 
     private statusTimer: NodeJS.Timeout | null = null;
@@ -52,12 +53,12 @@ export class DaemonStatusReporter {
 
     startReporting(): void {
         setTimeout(() => {
-            this.sendUnifiedStatusReport().catch(e => LOG.warn('Status', `Initial report failed: ${e?.message}`));
+            this.sendUnifiedStatusReport({ forceServer: true, reason: 'initial' }).catch(e => LOG.warn('Status', `Initial report failed: ${e?.message}`));
         }, 2000);
 
         const scheduleServerReport = () => {
             this.statusTimer = setTimeout(() => {
-                this.sendUnifiedStatusReport().catch(e => LOG.warn('Status', `Periodic report failed: ${e?.message}`));
+                this.sendUnifiedStatusReport({ forceServer: true, reason: 'periodic' }).catch(e => LOG.warn('Status', `Periodic report failed: ${e?.message}`));
                 scheduleServerReport();
             }, 30_000);
         };
@@ -135,7 +136,7 @@ export class DaemonStatusReporter {
             .join(', ');
     }
 
-    async sendUnifiedStatusReport(opts?: { p2pOnly?: boolean }): Promise<void> {
+    async sendUnifiedStatusReport(opts?: { p2pOnly?: boolean; forceServer?: boolean; reason?: string }): Promise<void> {
         const { serverConn, p2p } = this.deps;
         if (!serverConn?.isConnected()) return;
         this.lastStatusSentAt = Date.now();
@@ -216,6 +217,8 @@ export class DaemonStatusReporter {
 
  // ═══ Server transmit (minimal routing meta only) ═══
         if (opts?.p2pOnly) return;
+        // Server relay only needs compact session metadata for routing, compact status,
+        // initial_state fallback, and lightweight API/session inspection.
         const wsPayload = {
             daemonMode: true,
             sessions: sessions.map((session) => ({
@@ -232,23 +235,23 @@ export class DaemonStatusReporter {
                 currentModel: session.currentModel,
                 currentPlan: session.currentPlan,
                 currentAutoApprove: session.currentAutoApprove,
-                lastUpdated: session.lastUpdated,
-                unread: session.unread,
-                lastSeenAt: session.lastSeenAt,
-                inboxBucket: session.inboxBucket,
-                surfaceHidden: session.surfaceHidden,
-                controlValues: session.controlValues,
-                providerControls: session.providerControls,
-                acpConfigOptions: session.acpConfigOptions,
-                acpModes: session.acpModes,
             })),
             p2p: payload.p2p,
             timestamp: now,
             detectedIdes: payload.detectedIdes,
             availableProviders: payload.availableProviders,
         };
+        const wsHash = this.simpleHash(JSON.stringify({
+            ...wsPayload,
+            timestamp: undefined,
+        }));
+        if (!opts?.forceServer && wsHash === this.lastServerStatusHash) {
+            LOG.debug('Server', `skip duplicate status_report${opts?.reason ? ` (${opts.reason})` : ''}`);
+            return;
+        }
+        this.lastServerStatusHash = wsHash;
         serverConn.sendMessage('status_report', wsPayload);
-        LOG.debug('Server', `sent status_report (${JSON.stringify(wsPayload).length} bytes)`);
+        LOG.debug('Server', `sent status_report (${JSON.stringify(wsPayload).length} bytes)${opts?.reason ? ` [${opts.reason}]` : ''}`);
     }
 
  // ─── P2P ─────────────────────────────────────────

package/src/status/snapshot.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Shared status snapshot builders.
+ *
+ * Used by:
+ * - DaemonStatusReporter (cloud)
+ * - daemon-standalone HTTP/WS status responses
+ */
+import type { DaemonCdpManager } from '../cdp/manager.js';
+import type { ProviderState } from '../providers/provider-instance.js';
+import type { AvailableProviderInfo, StatusReportPayload } from '../shared-types.js';
+export interface StatusSnapshotOptions {
+    allStates: ProviderState[];
+    cdpManagers: Map<string, DaemonCdpManager>;
+    providerLoader: {
+        getAll(): Array<{
+            type: string;
+            icon?: string;
+            displayName?: string;
+            category: 'ide' | 'extension' | 'cli' | 'acp';
+        }>;
+        getAvailableProviderInfos?: () => Array<{
+            type: string;
+            icon?: string;
+            displayName?: string;
+            category: 'ide' | 'extension' | 'cli' | 'acp';
+            installed?: boolean;
+            detectedPath?: string | null;
+        }>;
+    };
+    detectedIdes: Array<{
+        id: string;
+        name?: string;
+        displayName?: string;
+        installed?: boolean;
+        path?: string;
+    }>;
+    instanceId: string;
+    version: string;
+    daemonMode: boolean;
+    timestamp?: number;
+    p2p?: StatusReportPayload['p2p'];
+    machineNickname?: string | null;
+}
+export interface StatusSnapshot extends StatusReportPayload {
+    availableProviders: AvailableProviderInfo[];
+}
+export declare function getSessionCompletionMarker(session: {
+    activeChat?: {
+        messages?: Array<{
+            role?: string;
+            id?: string;
+            index?: number;
+            receivedAt?: number | string;
+            _turnKey?: string;
+        }> | null;
+    } | null;
+}): string;
+export declare function buildStatusSnapshot(options: StatusSnapshotOptions): StatusSnapshot;

package/src/system/host-memory.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Host memory metrics — macOS-aware "available" memory.
+ *
+ * Node's os.freemem() on darwin reports only the tiny truly-free pool; most RAM
+ * sits in inactive/file-backed cache that the OS can reclaim. Dashboard "used %"
+ * based on (total - freemem) looks ~99% almost always — misleading.
+ *
+ * On macOS we parse `vm_stat` and approximate available bytes as:
+ *   (free + inactive + speculative + purgeable [+ file_backed]) × page size
+ * (aligned with common Activity Monitor–style interpretations.)
+ */
+export interface HostMemorySnapshot {
+    totalMem: number;
+    /** Raw kernel "free" — small on macOS; kept for debugging / API compat */
+    freeMem: number;
+    /** Use this for UI "used %" — on darwin from vm_stat; else equals freeMem */
+    availableMem: number;
+}
+export declare function getHostMemorySnapshot(): HostMemorySnapshot;

package/src/types.d.ts

@@ -4,7 +4,7 @@
  * Shared types referenced by daemon-core, daemon-standalone, and web-core.
  * When modifying this file, also update interface contracts in AGENT_PROTOCOL.md.
  */
-import type { StatusReportPayload } from './shared-types.js';
+import type { StatusReportPayload, AvailableProviderInfo } from './shared-types.js';
 /** Full status response from /api/v1/status and WS events */
 export interface StatusResponse extends StatusReportPayload {
     /** For standalone API compat */
@@ -15,7 +15,7 @@ export interface StatusResponse extends StatusReportPayload {
     /** User display name from config */
     userName?: string;
     /** Available providers */
-    availableProviders: ProviderInfo[];
+    availableProviders: AvailableProviderInfo[];
     /** System info (legacy compat) */
     system?: SystemInfo;
 }
@@ -111,11 +111,7 @@ export interface DetectedIde {
     installed: boolean;
     running: boolean;
 }
-export interface ProviderInfo {
-    type: string;
-    icon: string;
-    displayName: string;
-    category: string;
+export interface ProviderInfo extends AvailableProviderInfo {
 }
 /** Flattened agent entry from /api/v1/agents */
 export interface AgentEntry {