@adhdev/daemon-core 0.6.68 → 0.6.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.6.68",
+  "version": "0.6.70",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -34,6 +34,7 @@
     "@xterm/xterm": "^6.0.0",
     "chalk": "^5.3.0",
     "conf": "^13.0.0",
+    "node-pty": "^1.1.0",
     "ws": "^8.19.0"
   },
   "devDependencies": {

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/cli-adapters/provider-cli-adapter.ts

@@ -654,6 +654,8 @@ export class ProviderCliAdapter implements CliAdapter {
                 /Quick safety check/i,
                 /Is this a project/i,
                 /Enter to confirm/i,
+                /be able to read, edit, and execute/i,
+                /Security guide/i,
             ];
             if (dialogPatterns.some(p => p.test(this.startupBuffer))) {
                 setTimeout(() => this.ptyProcess?.write('\r'), this.timeouts.dialogAccept);
@@ -721,17 +723,46 @@ export class ProviderCliAdapter implements CliAdapter {
     }
 
     private evaluateSettled(): void {
-        if (this.submitPendingUntil > Date.now()) return;
-        if (this.responseSettleIgnoreUntil > Date.now()) return;
+        const now = Date.now();
+        if (this.submitPendingUntil > now || this.responseSettleIgnoreUntil > now) {
+            const delayTime = Math.max(this.submitPendingUntil - now, this.responseSettleIgnoreUntil - now) + 50;
+            if (this.settleTimer) clearTimeout(this.settleTimer);
+            this.settleTimer = setTimeout(() => {
+                this.settleTimer = null;
+                this.settledBuffer = this.recentOutputBuffer;
+                this.evaluateSettled();
+            }, delayTime);
+            return;
+        }
         const tail = this.settledBuffer;
         const modal = this.runParseApproval(tail);
         const rawScriptStatus = this.runDetectStatus(tail);
-        const scriptStatus = rawScriptStatus === 'waiting_approval' || modal ? 'waiting_approval' : rawScriptStatus;
+        // detectStatus is the sole authority for status. parseApproval only enriches modal info.
+        const scriptStatus = rawScriptStatus;
         if (!scriptStatus) return;
 
         const prevStatus = this.currentStatus;
 
         if (scriptStatus === 'waiting_approval') {
+            // Auto-accept startup safety dialogs (e.g., "Claude Code'll be able to read, edit, and execute")
+            const modalMessage = modal?.message || '';
+            const screenText = this.terminalScreen.getText() || this.accumulatedBuffer;
+            const autoAcceptPatterns = [
+                /be able to read, edit, and execute/i,
+                /Security guide/i,
+                /Enter to confirm/i,
+                /Quick safety check/i,
+                /Do you trust the files/i,
+                /Is this a project/i,
+            ];
+            if (autoAcceptPatterns.some(p => p.test(modalMessage) || p.test(screenText))) {
+                LOG.info('CLI', `[${this.cliType}] Auto-accepting startup dialog: ${modalMessage.slice(0, 80)}`);
+                setTimeout(() => this.ptyProcess?.write('\r'), 200);
+                this.lastApprovalResolvedAt = Date.now();
+                this.activeModal = null;
+                return;
+            }
+
             const inCooldown = this.lastApprovalResolvedAt && (Date.now() - this.lastApprovalResolvedAt) < this.timeouts.approvalCooldown;
             if (!inCooldown) {
                 this.isWaitingForResponse = true;

package/src/config/config.ts

@@ -7,6 +7,7 @@
 import { homedir } from 'os';
 import { join } from 'path';
 import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from 'fs';
+import { randomUUID } from 'crypto';
 import { migrateWorkspacesFromRecent } from './workspaces.js';
 import type { WorkspaceEntry } from './workspaces.js';
 import type { WorkspaceActivityEntry } from './workspace-activity.js';
@@ -64,12 +65,15 @@ export interface ADHDevConfig {
  // Machine nickname (user-customizable label for this machine)
     machineNickname: string | null;
 
- // Stable machine ID (prevents duplicate daemon entries when OS hostname changes dynamically)
+ // Stable local machine ID shared by standalone and cloud daemon modes
     machineId?: string;
 
  // Machine secret for server auth (replaces connectionToken)
     machineSecret?: string | null;
 
+ // Account-scoped registered machine row ID (cloud-side)
+    registeredMachineId?: string;
+
  // CLI launch history
     cliHistory: CliHistoryEntry[];
 
@@ -123,12 +127,44 @@ const DEFAULT_CONFIG: ADHDevConfig = {
     machineNickname: null,
     machineId: undefined,
     machineSecret: null,
+    registeredMachineId: undefined,
     cliHistory: [],
     providerSettings: {},
     ideSettings: {},
     disableUpstream: false,
 };
 
+const MACHINE_ID_PREFIX = 'mach_';
+
+export function generateMachineId(): string {
+    return `${MACHINE_ID_PREFIX}${randomUUID().replace(/-/g, '')}`;
+}
+
+export function isStableMachineId(machineId?: string | null): boolean {
+    return typeof machineId === 'string' && machineId.startsWith(MACHINE_ID_PREFIX);
+}
+
+function ensureMachineId(config: ADHDevConfig): { config: ADHDevConfig; changed: boolean } {
+    if (isStableMachineId(config.machineId)) {
+        return { config, changed: false };
+    }
+
+    // TODO(2026-04-06): Remove this legacy bridge after cloud clients have had
+    // time to persist registeredMachineId from the upgraded setup/login flow.
+    const legacyRegisteredMachineId = (!config.registeredMachineId && config.machineSecret && config.machineId)
+        ? config.machineId
+        : config.registeredMachineId;
+
+    return {
+        config: {
+            ...config,
+            machineId: generateMachineId(),
+            registeredMachineId: legacyRegisteredMachineId,
+        },
+        changed: true,
+    };
+}
+
 /**
  * Get the config directory path
  */
@@ -154,7 +190,11 @@ export function loadConfig(): ADHDevConfig {
     const configPath = getConfigPath();
 
     if (!existsSync(configPath)) {
-        return { ...DEFAULT_CONFIG };
+        const initialized = ensureMachineId({ ...DEFAULT_CONFIG });
+        try {
+            saveConfig(initialized.config);
+        } catch { /* ignore */ }
+        return initialized.config;
     }
 
     try {
@@ -166,30 +206,25 @@ export function loadConfig(): ADHDevConfig {
         }
         delete (merged as any).activeWorkspaceId;
         const hadStoredWorkspaces = Array.isArray(parsed.workspaces) && parsed.workspaces.length > 0;
-        migrateWorkspacesFromRecent(merged);
+        const ensured = ensureMachineId(merged);
+        const normalized = ensured.config as ADHDevConfig & { activeWorkspaceId?: string | null };
+        migrateWorkspacesFromRecent(normalized);
         
-        let configChanged = false;
-        if (!merged.machineId) {
-            const os = require('os');
-            const crypto = require('crypto');
-            const safeHostname = os.hostname().replace(/[^a-zA-Z0-9]/g, '_');
-            const machineHash = crypto.createHash('md5').update(os.hostname() + os.homedir()).digest('hex').slice(0, 8);
-            merged.machineId = `${safeHostname}_${machineHash}`;
-            configChanged = true;
-        }
+        let configChanged = ensured.changed;
 
-        if (!hadStoredWorkspaces && (merged.workspaces?.length || 0) > 0) {
+        if (!hadStoredWorkspaces && (normalized.workspaces?.length || 0) > 0) {
             configChanged = true;
         }
 
         if (configChanged) {
             try {
-                saveConfig(merged);
+                saveConfig(normalized);
             } catch { /* ignore */ }
         }
-        return merged;
+        return normalized;
     } catch {
-        return { ...DEFAULT_CONFIG };
+        const initialized = ensureMachineId({ ...DEFAULT_CONFIG });
+        return initialized.config;
     }
 }
 

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),
+    };
+}