@adhdev/daemon-core 0.5.3 → 0.5.6

package/src/config/workspaces.ts

@@ -0,0 +1,250 @@
+/**
+ * Saved workspaces — shared by IDE launch, CLI, ACP (daemon-local).
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { randomUUID } from 'crypto';
+import type { ADHDevConfig } from './config.js';
+
+export interface WorkspaceEntry {
+    id: string;
+    path: string;
+    label?: string;
+    addedAt: number;
+}
+
+const MAX_WORKSPACES = 50;
+
+export function expandPath(p: string): string {
+    const t = (p || '').trim();
+    if (!t) return '';
+    if (t.startsWith('~')) return path.join(os.homedir(), t.slice(1).replace(/^\//, ''));
+    return path.resolve(t);
+}
+
+export function validateWorkspacePath(absPath: string): { ok: true } | { ok: false; error: string } {
+    try {
+        if (!absPath) return { ok: false, error: 'Path required' };
+        if (!fs.existsSync(absPath)) return { ok: false, error: 'Path does not exist' };
+        const st = fs.statSync(absPath);
+        if (!st.isDirectory()) return { ok: false, error: 'Not a directory' };
+        return { ok: true };
+    } catch (e: any) {
+        return { ok: false, error: e?.message || 'Invalid path' };
+    }
+}
+
+/** Default workspace label from path */
+export function defaultWorkspaceLabel(absPath: string): string {
+    const base = path.basename(absPath) || absPath;
+    return base;
+}
+
+/**
+ * Ensure config.workspaces exists; seed from recentCliWorkspaces once (same paths).
+ */
+export function migrateWorkspacesFromRecent(config: ADHDevConfig): ADHDevConfig {
+    if (!config.workspaces) config.workspaces = [];
+    if (config.workspaces.length > 0) return config;
+
+    const recent = config.recentCliWorkspaces || [];
+    const now = Date.now();
+    for (const raw of recent) {
+        const abs = expandPath(raw);
+        if (!abs || validateWorkspacePath(abs).ok !== true) continue;
+        if (config.workspaces.some(w => path.resolve(w.path) === abs)) continue;
+        config.workspaces.push({
+            id: randomUUID(),
+            path: abs,
+            label: defaultWorkspaceLabel(abs),
+            addedAt: now,
+        });
+        if (config.workspaces.length >= MAX_WORKSPACES) break;
+    }
+    return config;
+}
+
+export function getDefaultWorkspacePath(config: ADHDevConfig): string | null {
+    const id = config.defaultWorkspaceId;
+    if (!id) return null;
+    const w = (config.workspaces || []).find(x => x.id === id);
+    if (!w) return null;
+    const abs = expandPath(w.path);
+    if (validateWorkspacePath(abs).ok !== true) return null;
+    return abs;
+}
+
+export function getWorkspaceState(config: ADHDevConfig): {
+    workspaces: WorkspaceEntry[];
+    defaultWorkspaceId: string | null;
+    defaultWorkspacePath: string | null;
+} {
+    const workspaces = [...(config.workspaces || [])].sort((a, b) => b.addedAt - a.addedAt);
+    const defaultWorkspacePath = getDefaultWorkspacePath(config);
+    return {
+        workspaces,
+        defaultWorkspaceId: config.defaultWorkspaceId ?? null,
+        defaultWorkspacePath,
+    };
+}
+
+export type LaunchDirectorySource = 'dir' | 'workspaceId' | 'defaultWorkspace' | 'home';
+
+export type ResolveLaunchDirectoryResult =
+    | { ok: true; path: string; source: LaunchDirectorySource }
+    | { ok: false; code: 'WORKSPACE_LAUNCH_CONTEXT_REQUIRED'; message: string };
+
+/**
+ * Resolve cwd for CLI/ACP. No implicit default workspace or home — caller must pass
+ * useDefaultWorkspace or useHome (or an explicit dir / workspaceId).
+ */
+export function resolveLaunchDirectory(
+    args: {
+        dir?: string;
+        workspaceId?: string;
+        useDefaultWorkspace?: boolean;
+        useHome?: boolean;
+    } | undefined,
+    config: ADHDevConfig,
+): ResolveLaunchDirectoryResult {
+    const a = args || {};
+    if (a.dir != null && String(a.dir).trim()) {
+        const abs = expandPath(String(a.dir).trim());
+        if (abs && validateWorkspacePath(abs).ok === true) {
+            return { ok: true, path: abs, source: 'dir' };
+        }
+        return {
+            ok: false,
+            code: 'WORKSPACE_LAUNCH_CONTEXT_REQUIRED',
+            message: abs ? 'Directory path is not valid or does not exist' : 'Invalid directory path',
+        };
+    }
+    if (a.workspaceId) {
+        const w = (config.workspaces || []).find(x => x.id === a.workspaceId);
+        if (w) {
+            const abs = expandPath(w.path);
+            if (validateWorkspacePath(abs).ok === true) {
+                return { ok: true, path: abs, source: 'workspaceId' };
+            }
+        }
+        return {
+            ok: false,
+            code: 'WORKSPACE_LAUNCH_CONTEXT_REQUIRED',
+            message: 'Saved workspace not found or path is no longer valid',
+        };
+    }
+    if (a.useDefaultWorkspace === true) {
+        const d = getDefaultWorkspacePath(config);
+        if (d) return { ok: true, path: d, source: 'defaultWorkspace' };
+        return {
+            ok: false,
+            code: 'WORKSPACE_LAUNCH_CONTEXT_REQUIRED',
+            message: 'No default workspace is set',
+        };
+    }
+    if (a.useHome === true) {
+        return { ok: true, path: os.homedir(), source: 'home' };
+    }
+    return {
+        ok: false,
+        code: 'WORKSPACE_LAUNCH_CONTEXT_REQUIRED',
+        message: 'Choose a directory, saved workspace, default workspace, or home before launching.',
+    };
+}
+
+/**
+ * IDE folder from explicit args only (`workspace`, `workspaceId`, or `useDefaultWorkspace: true`).
+ */
+export function resolveIdeWorkspaceFromArgs(
+    args: {
+        workspace?: string;
+        workspaceId?: string;
+        useDefaultWorkspace?: boolean;
+    } | undefined,
+    config: ADHDevConfig,
+): string | undefined {
+    const ar = args || {};
+    if (ar.workspace) {
+        const abs = expandPath(ar.workspace);
+        if (abs && validateWorkspacePath(abs).ok === true) return abs;
+    }
+    if (ar.workspaceId) {
+        const w = (config.workspaces || []).find(x => x.id === ar.workspaceId);
+        if (w) {
+            const abs = expandPath(w.path);
+            if (validateWorkspacePath(abs).ok === true) return abs;
+        }
+    }
+    if (ar.useDefaultWorkspace === true) {
+        return getDefaultWorkspacePath(config) || undefined;
+    }
+    return undefined;
+}
+
+/**
+ * IDE launch folder — same saved workspaces + default as CLI/ACP.
+ * After explicit `workspace` / `workspaceId` / `useDefaultWorkspace: true`, falls back to
+ * config default workspace when set. Pass `useDefaultWorkspace: false` to open IDE without that folder.
+ */
+export function resolveIdeLaunchWorkspace(
+    args: {
+        workspace?: string;
+        workspaceId?: string;
+        useDefaultWorkspace?: boolean;
+    } | undefined,
+    config: ADHDevConfig,
+): string | undefined {
+    const direct = resolveIdeWorkspaceFromArgs(args, config);
+    if (direct) return direct;
+    if (args?.useDefaultWorkspace === false) return undefined;
+    return getDefaultWorkspacePath(config) || undefined;
+}
+
+export function findWorkspaceByPath(config: ADHDevConfig, rawPath: string): WorkspaceEntry | undefined {
+    const abs = path.resolve(expandPath(rawPath));
+    if (!abs) return undefined;
+    return (config.workspaces || []).find(w => path.resolve(expandPath(w.path)) === abs);
+}
+
+export function addWorkspaceEntry(config: ADHDevConfig, rawPath: string, label?: string): { config: ADHDevConfig; entry: WorkspaceEntry } | { error: string } {
+    const abs = expandPath(rawPath);
+    const v = validateWorkspacePath(abs);
+    if (!v.ok) return { error: v.error };
+
+    const list = [...(config.workspaces || [])];
+    if (list.some(w => path.resolve(w.path) === abs)) {
+        return { error: 'Workspace already in list' };
+    }
+    if (list.length >= MAX_WORKSPACES) {
+        return { error: `Maximum ${MAX_WORKSPACES} workspaces` };
+    }
+    const entry: WorkspaceEntry = {
+        id: randomUUID(),
+        path: abs,
+        label: (label || '').trim() || defaultWorkspaceLabel(abs),
+        addedAt: Date.now(),
+    };
+    list.push(entry);
+    return { config: { ...config, workspaces: list }, entry };
+}
+
+export function removeWorkspaceEntry(config: ADHDevConfig, id: string): { config: ADHDevConfig } | { error: string } {
+    const list = (config.workspaces || []).filter(w => w.id !== id);
+    if (list.length === (config.workspaces || []).length) return { error: 'Workspace not found' };
+    let defaultWorkspaceId = config.defaultWorkspaceId;
+    if (defaultWorkspaceId === id) defaultWorkspaceId = null;
+    return { config: { ...config, workspaces: list, defaultWorkspaceId } };
+}
+
+export function setDefaultWorkspaceId(config: ADHDevConfig, id: string | null): { config: ADHDevConfig } | { error: string } {
+    if (id === null) {
+        return { config: { ...config, defaultWorkspaceId: null } };
+    }
+    const w = (config.workspaces || []).find(x => x.id === id);
+    if (!w) return { error: 'Workspace not found' };
+    const abs = expandPath(w.path);
+    if (validateWorkspacePath(abs).ok !== true) return { error: 'Workspace path is no longer valid' };
+    return { config: { ...config, defaultWorkspaceId: id } };
+}

package/src/daemon/dev-server.ts

@@ -2238,7 +2238,7 @@ export class DevServer {
     lines.push('## Required Return Format');
     lines.push('| Function | Return JSON |');
     lines.push('|---|---|');
-    lines.push('| readChat | `{ id, status, title, messages: [{role, content, index}], inputContent, activeModal }` |');
+    lines.push('| readChat | `{ id, status, title, messages: [{role, content, index, kind?, meta?}], inputContent, activeModal }` — optional `kind`: standard, thought, tool, terminal; optional `meta`: e.g. `{ label, isRunning }` for dashboard |');
     lines.push('| sendMessage | `{ sent: false, needsTypeAndSend: true, selector }` |');
     lines.push('| resolveAction | `{ resolved: true/false, clicked? }` |');
     lines.push('| listSessions | `{ sessions: [{ id, title, active, index }] }` |');

package/src/index.ts

@@ -29,11 +29,16 @@ export type { IDaemonCore, DaemonCoreOptions } from './daemon-core.js';
 
 // ── Config ──
 export { loadConfig, saveConfig, resetConfig, isSetupComplete, addCliHistory, markSetupComplete, updateConfig } from './config/config.js';
+export { getWorkspaceState } from './config/workspaces.js';
+export { getWorkspaceActivity } from './config/workspace-activity.js';
+export type { WorkspaceEntry } from './config/workspaces.js';
 
 // ── Detection ──
 export { detectIDEs } from './detection/ide-detector.js';
 export type { IDEInfo } from './detection/ide-detector.js';
 export { detectCLIs } from './detection/cli-detector.js';
+export { getHostMemorySnapshot } from './system/host-memory.js';
+export type { HostMemorySnapshot } from './system/host-memory.js';
 
 // ── CDP ──
 export { DaemonCdpManager } from './cdp/manager.js';

package/src/launch.ts

@@ -224,7 +224,7 @@ function detectCurrentWorkspace(ideId: string): string | undefined {
                 );
                 if (fs.existsSync(storagePath)) {
                     const data = JSON.parse(fs.readFileSync(storagePath, 'utf-8'));
- // openedPathsList.workspaces3 has recent folders
+ // openedPathsList.workspaces3 has recent workspace paths
                     const workspaces = data?.openedPathsList?.workspaces3 || data?.openedPathsList?.entries || [];
                     if (workspaces.length > 0) {
                         const recent = workspaces[0];

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

@@ -13,6 +13,7 @@ import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
 import type { CliProviderModule } from '../cli-adapters/provider-cli-adapter.js';
 import { StatusMonitor } from './status-monitor.js';
 import { ChatHistoryWriter } from '../config/chat-history.js';
+import { LOG } from '../logging/logger.js';
 
 export class CliProviderInstance implements ProviderInstance {
     readonly type: string;
@@ -156,18 +157,22 @@ export class CliProviderInstance implements ProviderInstance {
         const chatTitle = `${this.provider.name} · ${dirName}`;
 
         if (newStatus !== this.lastStatus) {
+            LOG.info('CLI', `[${this.type}] status: ${this.lastStatus} → ${newStatus}`);
             if (this.lastStatus === 'idle' && newStatus === 'generating') {
                 this.generatingStartedAt = now;
                 this.pushEvent({ event: 'agent:generating_started', chatTitle, timestamp: now });
             } else if (newStatus === 'waiting_approval') {
                 if (!this.generatingStartedAt) this.generatingStartedAt = now;
+                const modal = adapterStatus.activeModal;
+                LOG.info('CLI', `[${this.type}] approval modal: "${modal?.message?.slice(0, 80) ?? 'none'}"`);
                 this.pushEvent({
                     event: 'agent:waiting_approval', chatTitle, timestamp: now,
-                    modalMessage: adapterStatus.activeModal?.message,
-                    modalButtons: adapterStatus.activeModal?.buttons,
+                    modalMessage: modal?.message,
+                    modalButtons: modal?.buttons,
                 });
             } else if (newStatus === 'idle' && (this.lastStatus === 'generating' || this.lastStatus === 'waiting_approval')) {
                 const duration = this.generatingStartedAt ? Math.round((now - this.generatingStartedAt) / 1000) : 0;
+                LOG.info('CLI', `[${this.type}] completed in ${duration}s`);
                 this.pushEvent({ event: 'agent:generating_completed', chatTitle, duration, timestamp: now });
                 this.generatingStartedAt = 0;
             } else if (newStatus === 'stopped') {

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

@@ -274,6 +274,17 @@ export class IdeProviderInstance implements ProviderInstance {
                 msg.receivedAt = prevByHash.get(h) || now;
             }
 
+            // Filter messages by provider settings (showThinking, showToolCalls, showTerminal)
+            if (raw.messages?.length > 0) {
+                const hiddenKinds = new Set<string>();
+                if (this.settings.showThinking === false) hiddenKinds.add('thought');
+                if (this.settings.showToolCalls === false) hiddenKinds.add('tool');
+                if (this.settings.showTerminal === false) hiddenKinds.add('terminal');
+                if (hiddenKinds.size > 0) {
+                    raw.messages = raw.messages.filter((m: any) => !hiddenKinds.has(m.kind));
+                }
+            }
+
             this.cachedChat = { ...raw, activeModal };
             this.detectAgentTransitions(raw, now);
 

package/src/status/reporter.ts

@@ -8,6 +8,9 @@
 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';
 
 // ─── Daemon dependency interface ──────────────────────
@@ -95,6 +98,11 @@ export class DaemonStatusReporter {
  // (agent-stream polling backward compat)
     updateAgentStreams(_ideType: string, _streams: any[]): void { /* Managed by Instance itself */ }
 
+    /** Reset P2P dedup hash — forces next send to transmit even if content unchanged */
+    resetP2PHash(): void {
+        this.lastP2PStatusHash = '';
+    }
+
  // ─── Core ────────────────────────────────────────
 
     private ts(): string {
@@ -197,17 +205,26 @@ export class DaemonStatusReporter {
 
 
 
+        const cfg = loadConfig();
+        const wsState = getWorkspaceState(cfg);
+        const memSnap = getHostMemorySnapshot();
+
  // ═══ Assemble payload (P2P — required data only) ═══
         const payload: Record<string, any> = {
             daemonMode: true,
-            machineNickname: loadConfig().machineNickname || null,
+            machineNickname: cfg.machineNickname || null,
+            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: os.totalmem(),
-                freeMem: os.freemem(),
+                totalMem: memSnap.totalMem,
+                freeMem: memSnap.freeMem,
+                availableMem: memSnap.availableMem,
                 loadavg: os.loadavg(),
                 uptime: os.uptime(),
             },
@@ -243,6 +260,8 @@ export class DaemonStatusReporter {
             const wsPayload = {
                 daemonMode: true,
                 machineNickname: payload.machineNickname,
+                defaultWorkspaceId: wsState.defaultWorkspaceId,
+                workspaceCount: (wsState.workspaces || []).length,
  // managedIdes: server only saves id, type, cdpConnected
                 managedIdes: managedIdes.map(ide => ({
                     ideType: ide.ideType,
@@ -271,7 +290,7 @@ export class DaemonStatusReporter {
     private sendP2PPayload(payload: Record<string, any>): boolean {
         const { timestamp: _ts, system: _sys, ...hashTarget } = payload;
         if (hashTarget.machine) {
-            const { freeMem: _f, loadavg: _l, uptime: _u, ...stableMachine } = hashTarget.machine as any;
+            const { freeMem: _f, availableMem: _a, loadavg: _l, uptime: _u, ...stableMachine } = hashTarget.machine as any;
             hashTarget.machine = stableMachine;
         }
         const h = this.simpleHash(JSON.stringify(hashTarget));

package/src/system/host-memory.ts

@@ -0,0 +1,65 @@
+/**
+ * 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.)
+ */
+
+import * as os from 'os';
+import { execSync } from 'child_process';
+
+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;
+}
+
+function parseDarwinAvailableBytes(totalMem: number): number | null {
+    if (os.platform() !== 'darwin') return null;
+    try {
+        const out = execSync('vm_stat', {
+            encoding: 'utf-8',
+            timeout: 4000,
+            maxBuffer: 256 * 1024,
+        });
+        const pageSizeMatch = out.match(/page size of (\d+)\s*bytes/i);
+        const pageSize = pageSizeMatch ? parseInt(pageSizeMatch[1], 10) : 4096;
+
+        const counts: Record<string, number> = {};
+        for (const line of out.split('\n')) {
+            const m = line.match(/^\s*Pages\s+([^:]+):\s+([\d,]+)\s*\.?/);
+            if (!m) continue;
+            const key = m[1].trim().toLowerCase().replace(/\s+/g, '_');
+            const n = parseInt(m[2].replace(/,/g, ''), 10);
+            if (!Number.isNaN(n)) counts[key] = n;
+        }
+
+        const free = counts['free'] ?? 0;
+        const inactive = counts['inactive'] ?? 0;
+        const speculative = counts['speculative'] ?? 0;
+        const purgeable = counts['purgeable'] ?? 0;
+        const fileBacked = counts['file_backed'] ?? 0;
+
+        const availPages = free + inactive + speculative + purgeable + fileBacked;
+        const bytes = availPages * pageSize;
+        if (!Number.isFinite(bytes) || bytes < 0) return null;
+        return Math.min(bytes, totalMem);
+    } catch {
+        return null;
+    }
+}
+
+export function getHostMemorySnapshot(): HostMemorySnapshot {
+    const totalMem = os.totalmem();
+    const freeMem = os.freemem();
+    const darwinAvail = parseDarwinAvailableBytes(totalMem);
+    const availableMem = darwinAvail != null ? darwinAvail : freeMem;
+    return { totalMem, freeMem, availableMem };
+}

package/src/types.ts

@@ -43,7 +43,7 @@ export interface IdeEntry {
   agentStreams?: AgentStreamEntry[];
  /** Extension agents monitored via CDP */
   extensions?: ExtensionInfo[];
- /** Workspace folders */
+ /** IDE-reported workspace roots (name + path) */
   workspaceFolders?: { name: string; path: string }[];
  /** Active file path */
   activeFile?: string | null;
@@ -150,6 +150,8 @@ export interface SystemInfo {
   cpus: number;
   totalMem: number;
   freeMem: number;
+  /** macOS: reclaimable-inclusive; prefer for UI used% (see host-memory.ts) */
+  availableMem?: number;
   loadavg: number[];
   uptime: number;
   arch: string;
@@ -183,6 +185,11 @@ export interface StatusResponse {
   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 */