@adhdev/daemon-core 0.5.8 → 0.5.17

package/src/shared-types.ts

@@ -0,0 +1,203 @@
+/**
+ * ADHDev Shared Types — Cross-package type definitions
+ *
+ * Types used across daemon-core, web-core, web-cloud, server, etc.
+ * Import via: import type { ... } from '@adhdev/daemon-core/types'
+ *
+ * IMPORTANT: This file must remain runtime-free (types only).
+ * Cloudflare Workers (server) can import type-only modules safely.
+ */
+
+import type {
+    StatusResponse,
+    ChatMessage,
+    ExtensionInfo,
+    SystemInfo,
+    DetectedIde,
+    AgentEntry,
+} from './types.js';
+
+export type {
+    StatusResponse,
+    ChatMessage,
+    ExtensionInfo,
+    SystemInfo,
+    DetectedIde,
+    AgentEntry,
+};
+
+// Re-export provider types (except ProviderErrorReason which is defined below)
+export type {
+    ProviderState,
+    ProviderStatus,
+    ActiveChatData,
+    IdeProviderState,
+    CliProviderState,
+    AcpProviderState,
+    ExtensionProviderState,
+    ProviderEvent,
+} from './providers/provider-instance.js';
+
+// Re-export ProviderErrorReason (defined in this file, imported by provider-instance)
+export type { ProviderErrorReason } from './providers/provider-instance.js';
+
+// Local import for use in Managed*Entry types below
+import type { ActiveChatData as _ActiveChatData } from './providers/provider-instance.js';
+import type { WorkspaceEntry } from './config/workspaces.js';
+
+// Re-export WorkspaceEntry for downstream consumers
+export type { WorkspaceEntry } from './config/workspaces.js';
+
+// ─── Managed Entry Types (reporter → server/web) ────────────────────
+// These define the shape of data sent by DaemonStatusReporter
+// and consumed by web-core, web-cloud, and server.
+
+/** IDE entry as reported by daemon to server/dashboard */
+export interface ManagedIdeEntry {
+    ideType: string;
+    ideVersion: string;
+    instanceId: string;
+    workspace: string | null;
+    terminals: number;
+    aiAgents: unknown[];
+    activeChat: _ActiveChatData | null;
+    chats: unknown[];
+    agentStreams: ManagedAgentStream[];
+    cdpConnected: boolean;
+    currentModel?: string;
+    currentPlan?: string;
+    currentAutoApprove?: string;
+}
+
+/** CLI entry as reported by daemon to server/dashboard */
+export interface ManagedCliEntry {
+    id: string;
+    instanceId: string;
+    cliType: string;
+    cliName: string;
+    status: string;
+    mode: 'terminal' | 'chat';
+    workspace: string;
+    activeChat: _ActiveChatData | null;
+}
+
+/** ACP entry as reported by daemon to server/dashboard */
+export interface ManagedAcpEntry {
+    id: string;
+    acpType: string;
+    acpName: string;
+    status: string;
+    mode: 'chat';
+    workspace: string;
+    activeChat: _ActiveChatData | null;
+    currentModel?: string;
+    currentPlan?: string;
+    acpConfigOptions?: AcpConfigOption[];
+    acpModes?: AcpMode[];
+    /** Error details */
+    errorMessage?: string;
+    errorReason?: 'not_installed' | 'auth_failed' | 'spawn_error' | 'init_failed' | 'crash' | 'timeout' | 'cdp_error' | 'disconnected';
+}
+
+/** Agent stream within an IDE (extension status) */
+export interface ManagedAgentStream {
+    agentType: string;
+    agentName: string;
+    extensionId: string;
+    status: string;
+    messages: ChatMessage[];
+    inputContent: string;
+    model?: string;
+    activeModal: { message: string; buttons: string[] } | null;
+}
+
+/** Available provider information */
+export interface AvailableProviderInfo {
+    type: string;
+    name: string;
+    category: 'ide' | 'extension' | 'cli' | 'acp';
+    displayName: string;
+    icon: string;
+}
+
+/** ACP config option (model/mode/thought_level selection) */
+export interface AcpConfigOption {
+    category: 'model' | 'mode' | 'thought_level' | 'other';
+    configId: string;
+    currentValue?: string;
+    options: { value: string; name: string; description?: string; group?: string }[];
+}
+
+/** ACP mode */
+export interface AcpMode {
+    id: string;
+    name: string;
+    description?: string;
+}
+
+// ─── Common Sub-Types (used across StatusReportPayload, BaseDaemonData, etc.) ──
+
+/** Machine hardware/OS info (reported by daemon, displayed by web) */
+export interface MachineInfo {
+    hostname: string;
+    platform: string;
+    arch: string;
+    cpus: number;
+    totalMem: number;
+    freeMem: number;
+    /** macOS: reclaimable-inclusive; prefer for UI used% */
+    availableMem?: number;
+    loadavg: number[];
+    uptime: number;
+    release: string;
+}
+
+/** Detected IDE on a machine */
+export interface DetectedIdeInfo {
+    type: string;
+    id?: string;
+    name: string;
+    running: boolean;
+    path?: string;
+}
+
+/** Workspace recent activity */
+export interface WorkspaceActivity {
+    path: string;
+    lastUsedAt: number;
+    kind?: string;
+    agentType?: string;
+}
+
+// ─── Status Report Payload (daemon → server) ────────────────────────
+// Full payload shape sent via WebSocket status_report
+
+export interface StatusReportPayload {
+    /** Daemon instance ID */
+    instanceId: string;
+    /** Daemon version */
+    version: string;
+    /** Daemon mode flag */
+    daemonMode: boolean;
+    /** Machine info */
+    machine: MachineInfo;
+    /** Machine nickname (user-set) */
+    machineNickname?: string | null;
+    /** Timestamp */
+    timestamp: number;
+    /** Detected IDEs on this machine */
+    detectedIdes: DetectedIdeInfo[];
+    /** P2P state */
+    p2p?: { available: boolean; state: string; peers: number; screenshotActive?: boolean };
+    /** Managed IDE instances */
+    managedIdes: ManagedIdeEntry[];
+    /** Managed CLI instances */
+    managedClis: ManagedCliEntry[];
+    /** Managed ACP instances */
+    managedAcps: ManagedAcpEntry[];
+    /** Saved workspaces */
+    workspaces?: WorkspaceEntry[];
+    defaultWorkspaceId?: string | null;
+    defaultWorkspacePath?: string | null;
+    workspaceActivity?: WorkspaceActivity[];
+}

package/src/status/reporter.ts

@@ -12,6 +12,14 @@ import { getWorkspaceState } from '../config/workspaces.js';
 import { getHostMemorySnapshot } from '../system/host-memory.js';
 import { getWorkspaceActivity } from '../config/workspace-activity.js';
 import { LOG } from '../logging/logger.js';
+import type { ManagedIdeEntry, ManagedCliEntry, ManagedAcpEntry } from '../shared-types.js';
+import type {
+    ProviderState,
+    IdeProviderState,
+    CliProviderState,
+    AcpProviderState,
+    ExtensionProviderState,
+} from '../providers/provider-instance.js';
 
 // ─── Daemon dependency interface ──────────────────────
 
@@ -23,7 +31,8 @@ export interface StatusReporterDeps {
     adapters: Map<string, { cliType: string; cliName: string; workingDir: string; getStatus(): any; getPartialResponse(): string }>;
     detectedIdes: any[];
     ideType: string;
-    instanceManager: { collectAllStates(): any[]; collectStatesByCategory(cat: string): any[] };
+    daemonVersion?: string;
+    instanceManager: { collectAllStates(): ProviderState[]; collectStatesByCategory(cat: string): ProviderState[] };
 }
 
 export class DaemonStatusReporter {
@@ -117,21 +126,21 @@ export class DaemonStatusReporter {
         const target = opts?.p2pOnly ? 'P2P' : 'P2P+Server';
 
         const allStates = this.deps.instanceManager.collectAllStates();
-        const ideStates = allStates.filter((s: any) => s.category === 'ide');
-        const cliStates = allStates.filter((s: any) => s.category === 'cli');
-        const acpStates = allStates.filter((s: any) => s.category === 'acp');
+        const ideStates = allStates.filter((s): s is IdeProviderState => s.category === 'ide');
+        const cliStates = allStates.filter((s): s is CliProviderState => s.category === 'cli');
+        const acpStates = allStates.filter((s): s is AcpProviderState => s.category === 'acp');
 
  // IDE summary
-        const ideSummary = ideStates.map((s: any) => {
+        const ideSummary = ideStates.map((s) => {
             const msgs = s.activeChat?.messages?.length || 0;
-            const exts = (s.extensions || []).length;
+            const exts = s.extensions.length;
             return `${s.type}(${s.status},${msgs}msg,${exts}ext${s.currentModel ? ',model=' + s.currentModel : ''})`;
         }).join(', ');
 
  // CLI summary
-        const cliSummary = cliStates.map((s: any) => `${s.type}(${s.status})`).join(', ');
+        const cliSummary = cliStates.map((s) => `${s.type}(${s.status})`).join(', ');
  // ACP summary
-        const acpSummary = acpStates.map((s: any) => `${s.type}(${s.status})`).join(', ');
+        const acpSummary = acpStates.map((s) => `${s.type}(${s.status})`).join(', ');
 
  // P2P-only = 5s heartbeat → DEBUG, P2P+Server = 30s interval → INFO
         const logLevel = opts?.p2pOnly ? 'debug' : 'info';
@@ -148,17 +157,16 @@ export class DaemonStatusReporter {
         }
 
  // IDE states → managedIdes
-        const managedIdes: any[] = ideStates.map((s: any) => ({
+        const managedIdes: ManagedIdeEntry[] = ideStates.map((s) => ({
             ideType: s.type,
             ideVersion: '',
             instanceId: s.instanceId,
-            workspaceFolders: s.workspaceFolders || [],
-            activeFile: s.activeFile || null,
+            workspace: s.workspace || null,
             terminals: 0,
             aiAgents: [],
             activeChat: s.activeChat,
             chats: [],
-            agentStreams: (s.extensions || []).map((ext: any) => ({
+            agentStreams: s.extensions.map((ext) => ({
                 agentType: ext.type,
                 agentName: ext.name,
                 extensionId: ext.type,
@@ -167,7 +175,7 @@ export class DaemonStatusReporter {
                 inputContent: ext.activeChat?.inputContent || '',
                 activeModal: ext.activeChat?.activeModal || null,
             })),
-            cdpConnected: s.cdpConnected || false,
+            cdpConnected: s.cdpConnected,
             currentModel: s.currentModel,
             currentPlan: s.currentPlan,
             currentAutoApprove: s.currentAutoApprove,
@@ -177,30 +185,32 @@ export class DaemonStatusReporter {
 
 
  // CLI states → managedClis
-        const managedClis: any[] = cliStates.map((s: any) => ({
+        const managedClis: ManagedCliEntry[] = cliStates.map((s) => ({
             id: s.instanceId,
             instanceId: s.instanceId,
             cliType: s.type,
             cliName: s.name,
             status: s.status,
-            mode: s.mode || 'terminal',
-            workingDir: s.workingDir || '',
+            mode: s.mode,
+            workspace: s.workspace || '',
             activeChat: s.activeChat,
         }));
 
- // ACP states → managedAcps (separated into per-type arrays)
-        const managedAcps: any[] = acpStates.map((s: any) => ({
+ // ACP states → managedAcps
+        const managedAcps: ManagedAcpEntry[] = acpStates.map((s) => ({
             id: s.instanceId,
             acpType: s.type,
             acpName: s.name,
             status: s.status,
-            mode: 'chat',
-            workingDir: s.workingDir || '',
+            mode: s.mode,
+            workspace: s.workspace || '',
             activeChat: s.activeChat,
             currentModel: s.currentModel,
             currentPlan: s.currentPlan,
             acpConfigOptions: s.acpConfigOptions,
             acpModes: s.acpModes,
+            errorMessage: s.errorMessage,
+            errorReason: s.errorReason,
         }));
 
 
@@ -212,6 +222,7 @@ export class DaemonStatusReporter {
  // ═══ Assemble payload (P2P — required data only) ═══
         const payload: Record<string, any> = {
             daemonMode: true,
+            version: this.deps.daemonVersion || 'unknown',
             machineNickname: cfg.machineNickname || null,
             workspaces: wsState.workspaces,
             defaultWorkspaceId: wsState.defaultWorkspaceId,
@@ -237,7 +248,6 @@ export class DaemonStatusReporter {
                 peers: p2p?.connectedPeerCount || 0,
                 screenshotActive: p2p?.screenshotActive || false,
             },
-            cdpConnected: [...cdpManagers.values()].some(c => c.isConnected),
             connectedExtensions: [],
             detectedIdes: this.deps.detectedIdes || [],
             availableProviders: this.deps.providerLoader.getAll().map((p: any) => ({
@@ -277,7 +287,6 @@ export class DaemonStatusReporter {
                     id: a.id, acpType: a.acpType, acpName: a.acpName,
                 })),
                 p2p: payload.p2p,
-                cdpConnected: payload.cdpConnected,
                 timestamp: now,
             };
             serverConn.sendMessage('status_report', wsPayload);

package/src/types.ts

@@ -4,99 +4,45 @@
  * Shared types referenced by daemon-core, daemon-standalone, daemon-cloud, web-core.
  * When modifying this file, also update interface contracts in AGENT_PROTOCOL.md.
  */
+import type { ManagedIdeEntry, ManagedCliEntry, ManagedAcpEntry, WorkspaceEntry, WorkspaceActivity, StatusReportPayload } from './shared-types.js';
 
 // ── Daemon Status ──
 
-export interface DaemonStatus {
-  id: string;
-  type: string;
-  platform?: string;
-  hostname?: string;
-  nickname?: string;
-  cdpConnected?: boolean;
-  timestamp: number;
-  ides: IdeEntry[];
-  clis: CliEntry[];
-  acps?: AcpEntry[];
-}
-
-// ── IDE Entry ──
-
-export interface IdeEntry {
- /** Format: "{daemonId}:ide:{instanceId}" */
-  id: string;
-  instanceId: string;
- /** IDE type: "cursor", "windsurf", "vscode", etc. */
-  type: string;
-  name?: string;
-  cdpConnected?: boolean;
-  cdpPort?: number;
- /** Current chat messages (live) */
-  chats?: ChatMessage[];
- /** Active chat session */
-  activeChat?: Record<string, unknown> | null;
- /** Chat history (legacy) */
-  chatHistory?: unknown[];
- /** Agent status: 'idle' | 'working' */
-  agentStatus?: string;
- /** Agent streams from extensions */
-  agentStreams?: AgentStreamEntry[];
- /** Extension agents monitored via CDP */
-  extensions?: ExtensionInfo[];
- /** IDE-reported workspace roots (name + path) */
-  workspaceFolders?: { name: string; path: string }[];
- /** Active file path */
-  activeFile?: string | null;
- /** Current AI model */
-  currentModel?: string;
- /** Current AI mode/plan */
-  currentPlan?: string;
- /** Managed agents list */
-  agents?: unknown[];
-}
-
-// ── CLI Entry ──
-
-export interface CliEntry {
- /** Format: "{daemonId}:cli:{cliId}" */
-  id: string;
-  cliId: string;
- /** CLI type: "gemini-cli", "claude-code", "codex-cli", etc. */
-  type: string;
-  name?: string;
- /** Whether the CLI process is running */
-  isRunning?: boolean;
- /** Active session info */
-  sessionId?: string;
-}
-
-// ── ACP Entry ──
-
-export interface AcpEntry {
- /** Format: "{daemonId}:acp:{acpId}" */
-  id: string;
-  acpId: string;
- /** Agent type: "gemini-acp", "cline-acp", etc. */
-  type: string;
-  name?: string;
- /** Process running state */
-  isRunning?: boolean;
- /** Error state */
-  errorReason?: string;
-  errorMessage?: string;
+/** Full status response from /api/v1/status and WS events */
+export interface StatusResponse extends StatusReportPayload {
+  /** For standalone API compat */
+  id: string; // standalone specific
+  type: string; // usually 'standalone'
+  platform: string;
+  hostname: string;
+  /** User display name from config */
+  userName?: string;
+  /** Available providers */
+  availableProviders: ProviderInfo[];
+  /** System info (legacy compat) */
+  system?: SystemInfo;
 }
 
 // ── Chat Message ──
 
 export interface ChatMessage {
-  role: string;       // 'user' | 'assistant' | 'human' | 'system'
+  role: string;       // 'user' | 'assistant' | 'system' | 'human'
   /** Plain text (legacy) or rich content blocks (ACP standard) */
   content: string | ContentBlock[];
-  kind?: string;      // 'standard' | 'thought' | 'tool' | 'system'
+  kind?: string;      // 'standard' | 'thought' | 'tool' | 'terminal' | 'system'
   id?: string;
+  index?: number;
   timestamp?: number;
+  receivedAt?: number;
   /** Tool calls associated with this message */
   toolCalls?: ToolCallInfo[];
+  /** Optional: fiber metadata */
+  _type?: string;
+  _sub?: string;
+  /** Meta information for thought/terminal logs etc */
+  meta?: { label?: string; isRunning?: boolean } | Record<string, any>;
+  /** Sender name for shared sessions */
+  senderName?: string;
 }
 
 // Re-export from contracts for convenience
@@ -138,7 +84,7 @@ export interface ProviderConfig {
 // ── Event Types ──
 
 export type DaemonEvent =
-  | { type: 'status'; data: DaemonStatus }
+  | { type: 'status'; data: StatusResponse }
   | { type: 'chat_update'; data: { ideId: string; messages: ChatMessage[] } }
   | { type: 'screenshot'; data: { ideId: string; base64: string } }
   | { type: 'action_log'; data: { ideId: string; text: string; timestamp: number } }
@@ -172,36 +118,6 @@ export interface ProviderInfo {
   category: string;
 }
 
-/** Full status response from /api/v1/status */
-export interface StatusResponse {
-  id: string;
-  type: string;
-  platform: string;
-  hostname: string;
-  timestamp: number;
-  ides: IdeEntry[];
-  clis: CliEntry[];
-  cdpConnected: boolean;
-  detectedIdes: DetectedIde[];
-  availableProviders: ProviderInfo[];
-  system: SystemInfo;
-  /** Saved workspaces (standalone WS / HTTP status) */
-  workspaces?: { id: string; path: string; label?: string; addedAt: number }[];
-  defaultWorkspaceId?: string | null;
-  defaultWorkspacePath?: string | null;
-  workspaceActivity?: { path: string; lastUsedAt: number; kind?: string; agentType?: string }[];
-}
-
-/** Agent stream entry within an IDE */
-export interface AgentStreamEntry {
-  agentType: string;
-  agentName: string;
-  extensionId: string;
-  status: string;
-  messages: unknown[];
-  inputContent: string;
-  activeModal: { message: string; buttons: string[] } | null;
-}
 
 /** Flattened agent entry from /api/v1/agents */
 export interface AgentEntry {