@adhdev/daemon-core 0.6.68 → 0.6.69

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.6.68",
+  "version": "0.6.69",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/agent-stream/forward.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared helper for forwarding agent stream snapshots into the IDE instance.
+ *
+ * Both cloud and standalone daemons use the same InstanceManager wiring.
+ */
+
+export function forwardAgentStreamsToIdeInstance(
+    instanceManager: { getInstance: (key: string) => any },
+    ideType: string,
+    streams: any[],
+): void {
+    const ideInstance = instanceManager.getInstance(`ide:${ideType}`) as
+        | { onEvent?: (event: string, payload: Record<string, unknown>) => void }
+        | undefined;
+
+    if (!ideInstance?.onEvent) return;
+
+    for (const stream of streams) {
+        ideInstance.onEvent('stream_update', {
+            extensionType: stream.agentType,
+            streams: [stream],
+            messages: stream.messages || [],
+            status: stream.status || 'idle',
+            activeModal: stream.activeModal || null,
+            model: stream.model || undefined,
+            mode: stream.mode || undefined,
+        });
+    }
+}

package/src/index.ts

@@ -75,6 +75,8 @@ export type { CommandRouterDeps, CommandRouterResult } from './commands/router.j
 // ── Status ──
 export { DaemonStatusReporter } from './status/reporter.js';
 export { buildManagedIdes, buildManagedClis, buildManagedAcps, buildAllManagedEntries, findCdpManager, hasCdpManager, isCdpConnected } from './status/builders.js';
+export { buildStatusSnapshot } from './status/snapshot.js';
+export type { StatusSnapshotOptions, StatusSnapshot } from './status/snapshot.js';
 
 // ── Logger ──
 export { LOG, installGlobalInterceptor, setLogLevel, getLogLevel, getRecentLogs } from './logging/logger.js';
@@ -97,6 +99,7 @@ export { readChatHistory } from './config/chat-history.js';
 export { DaemonAgentStreamManager } from './agent-stream/index.js';
 export { AgentStreamPoller } from './agent-stream/index.js';
 export type { AgentStreamPollerDeps } from './agent-stream/index.js';
+export { forwardAgentStreamsToIdeInstance } from './agent-stream/forward.js';
 
 // ── Providers ──
 export { ProviderLoader } from './providers/provider-loader.js';
@@ -122,4 +125,3 @@ export type { ExtensionInfo as InstallerExtensionInfo } from './installer.js';
 // ── Boot / Lifecycle ──
 export { initDaemonComponents, shutdownDaemonComponents } from './boot/daemon-lifecycle.js';
 export type { DaemonInitConfig, DaemonComponents } from './boot/daemon-lifecycle.js';
-

package/src/status/reporter.ts

@@ -5,14 +5,9 @@
  * Each Instance manages its own status/transition. This module only assembles + transmits.
  */
 
-import * as os from 'os';
-import * as path from 'path';
-import { loadConfig } from '../config/config.js';
-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 { buildAllManagedEntries } from './builders.js';
+import { buildStatusSnapshot } from './snapshot.js';
 import type {
     ProviderState,
     IdeProviderState,
@@ -27,9 +22,8 @@ export interface StatusReporterDeps {
     cdpManagers: Map<string, { isConnected: boolean }>;
     p2p: { isConnected: boolean; isAvailable: boolean; connectionState: string; connectedPeerCount: number; screenshotActive: boolean; sendStatus(data: any): void } | null;
     providerLoader: { resolve(type: string): any; getAll(): any[] };
-    adapters: Map<string, { cliType: string; cliName: string; workingDir: string; getStatus(): any; getPartialResponse(): string }>;
     detectedIdes: any[];
-    ideType: string;
+    instanceId: string;
     daemonVersion?: string;
     instanceManager: { collectAllStates(): ProviderState[]; collectStatesByCategory(cat: string): ProviderState[] };
     getScreenshotUsage?: () => { dailyUsedMinutes: number; dailyBudgetMinutes: number; budgetExhausted: boolean } | null;
@@ -163,50 +157,26 @@ export class DaemonStatusReporter {
             this.deps.cdpManagers as Map<string, any>,
         );
 
-
-
-
-
-        const cfg = loadConfig();
-        const wsState = getWorkspaceState(cfg);
-        const memSnap = getHostMemorySnapshot();
-
  // ═══ Assemble payload (P2P — required data only) ═══
         const payload: Record<string, any> = {
-            daemonMode: true,
-            version: this.deps.daemonVersion || 'unknown',
-            workspaces: wsState.workspaces,
-            defaultWorkspaceId: wsState.defaultWorkspaceId,
-            defaultWorkspacePath: wsState.defaultWorkspacePath,
-            workspaceActivity: getWorkspaceActivity(cfg, 15),
-            machine: {
-                hostname: os.hostname(),
-                platform: os.platform(),
-                arch: os.arch(),
-                cpus: os.cpus().length,
-                totalMem: memSnap.totalMem,
-                freeMem: memSnap.freeMem,
-                availableMem: memSnap.availableMem,
-                loadavg: os.loadavg(),
-                uptime: os.uptime(),
-            },
-            managedIdes,
-            managedClis,
-            managedAcps,
-            p2p: {
-                available: p2p?.isAvailable || false,
-                state: p2p?.connectionState || 'unavailable',
-                peers: p2p?.connectedPeerCount || 0,
-                screenshotActive: p2p?.screenshotActive || false,
-            },
+            ...buildStatusSnapshot({
+                allStates,
+                cdpManagers: this.deps.cdpManagers as Map<string, unknown>,
+                providerLoader: this.deps.providerLoader,
+                detectedIdes: this.deps.detectedIdes || [],
+                instanceId: this.deps.instanceId,
+                version: this.deps.daemonVersion || 'unknown',
+                daemonMode: true,
+                timestamp: now,
+                p2p: {
+                    available: p2p?.isAvailable || false,
+                    state: p2p?.connectionState || 'unavailable',
+                    peers: p2p?.connectedPeerCount || 0,
+                    screenshotActive: p2p?.screenshotActive || false,
+                },
+            }),
             screenshotUsage: this.deps.getScreenshotUsage?.() || null,
             connectedExtensions: [],
-            detectedIdes: this.deps.detectedIdes || [],
-            availableProviders: this.deps.providerLoader.getAll().map((p: any) => ({
-                type: p.type, icon: p.icon || '💻', displayName: p.displayName || p.type,
-                category: p.category,
-            })),
-            timestamp: now,
         };
 
  // ═══ P2P transmit ═══

package/src/status/snapshot.ts

@@ -0,0 +1,123 @@
+/**
+ * Shared status snapshot builders.
+ *
+ * Used by:
+ * - DaemonStatusReporter (cloud)
+ * - daemon-standalone HTTP/WS status responses
+ */
+
+import * as os from 'os';
+import { loadConfig } from '../config/config.js';
+import { getWorkspaceState } from '../config/workspaces.js';
+import { getWorkspaceActivity } from '../config/workspace-activity.js';
+import { getHostMemorySnapshot } from '../system/host-memory.js';
+import { buildAllManagedEntries, isCdpConnected } from './builders.js';
+import type { ProviderState } from '../providers/provider-instance.js';
+import type {
+    AvailableProviderInfo,
+    DetectedIdeInfo,
+    StatusReportPayload,
+} from '../shared-types.js';
+
+export interface StatusSnapshotOptions {
+    allStates: ProviderState[];
+    cdpManagers: Map<string, unknown>;
+    providerLoader: {
+        getAll(): Array<{
+            type: string;
+            icon?: string;
+            displayName?: string;
+            category: 'ide' | 'extension' | 'cli' | 'acp';
+        }>;
+    };
+    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[];
+}
+
+function buildDetectedIdeInfos(
+    detectedIdes: StatusSnapshotOptions['detectedIdes'],
+    cdpManagers: StatusSnapshotOptions['cdpManagers'],
+): DetectedIdeInfo[] {
+    return detectedIdes
+        .filter((ide) => ide.installed !== false)
+        .map((ide) => ({
+            id: ide.id,
+            type: ide.id,
+            name: ide.displayName || ide.name || ide.id,
+            running: isCdpConnected(cdpManagers as Map<string, any>, ide.id),
+            ...(ide.path ? { path: ide.path } : {}),
+        }));
+}
+
+function buildAvailableProviders(
+    providerLoader: StatusSnapshotOptions['providerLoader'],
+): AvailableProviderInfo[] {
+    return providerLoader.getAll().map((provider) => ({
+        type: provider.type,
+        name: provider.displayName || provider.type,
+        displayName: provider.displayName || provider.type,
+        icon: provider.icon || '💻',
+        category: provider.category,
+    }));
+}
+
+export function buildStatusSnapshot(options: StatusSnapshotOptions): StatusSnapshot {
+    const cfg = loadConfig();
+    const wsState = getWorkspaceState(cfg);
+    const memSnap = getHostMemorySnapshot();
+    const { managedIdes, managedClis, managedAcps } = buildAllManagedEntries(
+        options.allStates,
+        options.cdpManagers as Map<string, any>,
+        {
+            detectedIdes: options.detectedIdes.map((ide) => ({
+                id: ide.id,
+                installed: ide.installed !== false,
+            })),
+        },
+    );
+
+    return {
+        instanceId: options.instanceId,
+        version: options.version,
+        daemonMode: options.daemonMode,
+        machine: {
+            hostname: os.hostname(),
+            platform: os.platform(),
+            arch: os.arch(),
+            cpus: os.cpus().length,
+            totalMem: memSnap.totalMem,
+            freeMem: memSnap.freeMem,
+            availableMem: memSnap.availableMem,
+            loadavg: os.loadavg(),
+            uptime: os.uptime(),
+            release: os.release(),
+        },
+        machineNickname: options.machineNickname ?? cfg.machineNickname ?? null,
+        timestamp: options.timestamp ?? Date.now(),
+        detectedIdes: buildDetectedIdeInfos(options.detectedIdes, options.cdpManagers),
+        ...(options.p2p ? { p2p: options.p2p } : {}),
+        managedIdes,
+        managedClis,
+        managedAcps,
+        workspaces: wsState.workspaces,
+        defaultWorkspaceId: wsState.defaultWorkspaceId,
+        defaultWorkspacePath: wsState.defaultWorkspacePath,
+        workspaceActivity: getWorkspaceActivity(cfg, 15),
+        availableProviders: buildAvailableProviders(options.providerLoader),
+    };
+}