@adhdev/daemon-core 0.8.52 → 0.8.53

package/src/providers/provider-schema.ts

@@ -0,0 +1,154 @@
+import type { ProviderControlDef, ProviderControlType, ProviderModule } from './contracts.js'
+
+const KNOWN_PROVIDER_FIELDS = new Set<string>([
+  'type',
+  'name',
+  'category',
+  'aliases',
+  'cdpPorts',
+  'targetFilter',
+  'cli',
+  'icon',
+  'displayName',
+  'install',
+  'versionCommand',
+  'testedVersions',
+  'processNames',
+  'launch',
+  'paths',
+  'extensionId',
+  'extensionIdPattern',
+  'extensionIdPattern_flags',
+  'compatibility',
+  'defaultScriptDir',
+  'binary',
+  'spawn',
+  'approvalKeys',
+  'patterns',
+  'cleanOutput',
+  'resume',
+  'sessionProbe',
+  'approvalPositiveHints',
+  'scripts',
+  'vscodeCommands',
+  'inputMethod',
+  'inputSelector',
+  'webviewMatchText',
+  'os',
+  'versions',
+  'overrides',
+  'settings',
+  'controls',
+  'staticConfigOptions',
+  'spawnArgBuilder',
+  'auth',
+  'contractVersion',
+  'capabilities',
+  'providerVersion',
+  'status',
+  'details',
+  'sendDelayMs',
+  'sendKey',
+  'submitStrategy',
+  'disableUpstream',
+])
+
+const VALUE_CONTROL_TYPES = new Set<ProviderControlType>(['select', 'toggle', 'cycle', 'slider'])
+
+export interface ProviderValidationResult {
+  errors: string[]
+  warnings: string[]
+}
+
+export function validateProviderDefinition(raw: unknown): ProviderValidationResult {
+  const errors: string[] = []
+  const warnings: string[] = []
+
+  if (!raw || typeof raw !== 'object') {
+    return { errors: ['Provider definition must be an object'], warnings }
+  }
+
+  const provider = raw as Record<string, unknown>
+
+  if (!provider.type) errors.push('Missing required field: type')
+  if (!provider.name) errors.push('Missing required field: name')
+  if (!provider.category) {
+    errors.push('Missing required field: category')
+  } else if (!['ide', 'extension', 'cli', 'acp'].includes(String(provider.category))) {
+    errors.push(`Invalid category: ${String(provider.category)}`)
+  }
+
+  for (const key of Object.keys(provider)) {
+    if (!KNOWN_PROVIDER_FIELDS.has(key)) {
+      warnings.push(`Unknown provider field: ${key}`)
+    }
+  }
+
+  const category = provider.category
+  if ((category === 'cli' || category === 'acp')) {
+    const spawn = provider.spawn
+    const command = spawn && typeof spawn === 'object'
+      ? (spawn as Record<string, unknown>).command
+      : undefined
+    if (!spawn || typeof spawn !== 'object') {
+      errors.push(`${String(category).toUpperCase()}/CLI providers must have spawn config`)
+    } else if (typeof command !== 'string' || !command.trim()) {
+      errors.push('spawn.command is required')
+    }
+  }
+
+  if ((category === 'ide' || category === 'extension') && provider.cdpPorts !== undefined) {
+    if (!Array.isArray(provider.cdpPorts) || provider.cdpPorts.length === 0) {
+      warnings.push('IDE/Extension providers should have cdpPorts')
+    }
+  }
+
+  if (category === 'extension' && !provider.extensionId) {
+    warnings.push('Extension providers should have extensionId')
+  }
+
+  for (const control of Array.isArray(provider.controls) ? provider.controls : []) {
+    validateControl(control as ProviderControlDef, errors)
+  }
+
+  return { errors, warnings }
+}
+
+function validateControl(control: ProviderControlDef, errors: string[]): void {
+  if (!control || typeof control !== 'object') {
+    errors.push('controls: each control must be an object')
+    return
+  }
+
+  const id = typeof control.id === 'string' && control.id.trim() ? control.id.trim() : 'unknown'
+  const prefix = `controls.${id}`
+
+  if (!control.id || !String(control.id).trim()) errors.push(`${prefix}: id is required`)
+  if (!control.type) errors.push(`${prefix}: type is required`)
+  if (!control.label || !String(control.label).trim()) errors.push(`${prefix}: label is required`)
+  if (!control.placement) errors.push(`${prefix}: placement is required`)
+
+  if (control.dynamic && !control.listScript) {
+    errors.push(`${prefix}: dynamic controls require listScript`)
+  }
+
+  if (VALUE_CONTROL_TYPES.has(control.type) && !control.setScript) {
+    errors.push(`${prefix}: ${control.type} controls require setScript`)
+  }
+
+  if (control.type === 'action' && !control.invokeScript) {
+    errors.push(`${prefix}: action controls require invokeScript`)
+  }
+
+  if (control.type === 'slider') {
+    if (typeof control.min !== 'number' || typeof control.max !== 'number') {
+      errors.push(`${prefix}: slider controls require numeric min and max`)
+    } else if (control.min > control.max) {
+      errors.push(`${prefix}: slider min cannot exceed max`)
+    }
+  }
+
+  if (control.readFrom !== undefined && (typeof control.readFrom !== 'string' || !control.readFrom.trim())) {
+    errors.push(`${prefix}: readFrom must be a non-empty string when provided`)
+  }
+}

package/src/session-host/runtime-surface.ts

@@ -0,0 +1,80 @@
+import type { SessionHostRecord } from '../shared-types.js';
+
+export type SessionHostSurfaceKind = 'live_runtime' | 'recovery_snapshot' | 'inactive_record';
+
+export interface SessionHostSurfaceRecordLike {
+    lifecycle?: string | null;
+    meta?: Record<string, unknown> | null;
+}
+
+const LIVE_LIFECYCLES = new Set(['starting', 'running', 'stopping', 'interrupted']);
+
+export function isSessionHostLiveRuntime(record: SessionHostSurfaceRecordLike | null | undefined): boolean {
+    const lifecycle = String(record?.lifecycle || '').trim();
+    return LIVE_LIFECYCLES.has(lifecycle);
+}
+
+export function getSessionHostRecoveryLabel(meta: Record<string, unknown> | null | undefined): string | null {
+    const recoveryState = typeof meta?.runtimeRecoveryState === 'string'
+        ? String(meta.runtimeRecoveryState).trim()
+        : '';
+    if (!recoveryState) return null;
+    if (recoveryState === 'auto_resumed') return 'restored after restart';
+    if (recoveryState === 'resume_failed') return 'restore failed';
+    if (recoveryState === 'host_restart_interrupted') return 'host restart interrupted';
+    if (recoveryState === 'orphan_snapshot') return 'snapshot recovered';
+    return recoveryState.replace(/_/g, ' ');
+}
+
+export function isSessionHostRecoverySnapshot(record: SessionHostSurfaceRecordLike | null | undefined): boolean {
+    if (!record) return false;
+    if (isSessionHostLiveRuntime(record)) return false;
+
+    const lifecycle = String(record.lifecycle || '').trim();
+    if (lifecycle && lifecycle !== 'stopped' && lifecycle !== 'failed') {
+        return false;
+    }
+
+    const meta = record.meta || undefined;
+    if (meta?.restoredFromStorage === true) return true;
+    return getSessionHostRecoveryLabel(meta) !== null;
+}
+
+export function getSessionHostSurfaceKind(record: SessionHostSurfaceRecordLike | null | undefined): SessionHostSurfaceKind {
+    if (isSessionHostLiveRuntime(record)) return 'live_runtime';
+    if (isSessionHostRecoverySnapshot(record)) return 'recovery_snapshot';
+    return 'inactive_record';
+}
+
+export function partitionSessionHostRecords<T extends SessionHostSurfaceRecordLike>(records: T[]): {
+    liveRuntimes: T[];
+    recoverySnapshots: T[];
+    inactiveRecords: T[];
+} {
+    const liveRuntimes: T[] = [];
+    const recoverySnapshots: T[] = [];
+    const inactiveRecords: T[] = [];
+
+    for (const record of records) {
+        const kind = getSessionHostSurfaceKind(record);
+        if (kind === 'live_runtime') {
+            liveRuntimes.push(record);
+        } else if (kind === 'recovery_snapshot') {
+            recoverySnapshots.push(record);
+        } else {
+            inactiveRecords.push(record);
+        }
+    }
+
+    return {
+        liveRuntimes,
+        recoverySnapshots,
+        inactiveRecords,
+    };
+}
+
+export function partitionSessionHostDiagnosticsSessions(
+    records: SessionHostRecord[] | null | undefined,
+): ReturnType<typeof partitionSessionHostRecords<SessionHostRecord>> {
+    return partitionSessionHostRecords(records || []);
+}

package/src/session-host/startup-restore-policy.d.ts

@@ -0,0 +1 @@
+export declare function shouldAutoRestoreHostedSessionsOnStartup(env?: NodeJS.ProcessEnv): boolean;

package/src/session-host/startup-restore-policy.js

@@ -0,0 +1,7 @@
+export function shouldAutoRestoreHostedSessionsOnStartup(env = process.env) {
+  const raw = typeof env.ADHDEV_RESTORE_HOSTED_SESSIONS_ON_STARTUP === 'string'
+    ? env.ADHDEV_RESTORE_HOSTED_SESSIONS_ON_STARTUP.trim().toLowerCase()
+    : ''
+
+  return raw === '1' || raw === 'true' || raw === 'yes'
+}

package/src/session-host/startup-restore-policy.ts

@@ -0,0 +1,7 @@
+export function shouldAutoRestoreHostedSessionsOnStartup(env: NodeJS.ProcessEnv = process.env): boolean {
+  const raw = typeof env.ADHDEV_RESTORE_HOSTED_SESSIONS_ON_STARTUP === 'string'
+    ? env.ADHDEV_RESTORE_HOSTED_SESSIONS_ON_STARTUP.trim().toLowerCase()
+    : ''
+
+  return raw === '1' || raw === 'true' || raw === 'yes'
+}

package/src/shared-types.ts

@@ -110,6 +110,7 @@ export interface SessionHostRecord {
     providerType: string;
     workspace: string;
     lifecycle: 'starting' | 'running' | 'stopping' | 'stopped' | 'failed' | 'interrupted';
+    surfaceKind?: 'live_runtime' | 'recovery_snapshot' | 'inactive_record';
     writeOwner: SessionHostWriteOwner | null;
     attachedClients: SessionHostAttachedClient[];
     osPid?: number;
@@ -152,6 +153,9 @@ export interface SessionHostDiagnosticsSnapshot {
     endpoint: string;
     runtimeCount: number;
     sessions?: SessionHostRecord[];
+    liveRuntimes?: SessionHostRecord[];
+    recoverySnapshots?: SessionHostRecord[];
+    inactiveRecords?: SessionHostRecord[];
     recentLogs: SessionHostLogEntry[];
     recentRequests: SessionHostRequestTrace[];
     recentTransitions: SessionHostRuntimeTransition[];
@@ -411,6 +415,8 @@ export interface ProviderControlSchema {
     step?: number;
     /** Sort order */
     order?: number;
+    /** Hide this control even if it would otherwise render */
+    hidden?: boolean;
 }
 
 // ─── Common Sub-Types (used across StatusReportPayload, BaseDaemonData, etc.) ──

package/src/status/builders.ts

@@ -9,7 +9,7 @@
  */
 
 import type { DaemonCdpManager } from '../cdp/manager.js';
-import type { SessionEntry, SessionCapability, ProviderControlSchema, AcpConfigOption, AcpMode } from '../shared-types.js';
+import type { SessionEntry, SessionCapability } from '../shared-types.js';
 import type {
     IdeProviderState,
     CliProviderState,
@@ -104,66 +104,6 @@ export function isCdpConnected(
     return false;
 }
 
-/**
- * Build legacy controls for providers that haven't been updated to the new schema.
- * Replaces the frontend fallback logic.
- */
-function buildFallbackControls(
-    providerControls?: ProviderControlSchema[],
-    serverModel?: string,
-    serverMode?: string,
-    acpConfigOptions?: AcpConfigOption[],
-    acpModes?: AcpMode[],
-): ProviderControlSchema[] {
-    if (providerControls && providerControls.length > 0) return providerControls;
-    const controls: ProviderControlSchema[] = [];
-
-    const isAcp = !!(acpConfigOptions || acpModes);
-
-    // Legacy model control
-    const modelFromAcp = acpConfigOptions?.find(c => c.category === 'model');
-    if (!isAcp || modelFromAcp) {
-        controls.push({
-            id: 'model',
-            type: 'select',
-            label: 'Model',
-            icon: '🤖',
-            placement: 'bar',
-            dynamic: !modelFromAcp,
-            listScript: 'listModels',
-            setScript: 'setModel',
-            readFrom: 'model',
-            ...(modelFromAcp && {
-                options: modelFromAcp.options.map((o: any) => ({ value: o.value, label: o.name || o.value })),
-            }),
-        });
-    }
-
-    // Legacy mode control
-    const modeFromAcp = acpModes && acpModes.length > 0;
-    const thoughtFromAcp = !modeFromAcp && acpConfigOptions?.find((c: any) => c.category !== 'model');
-    if (!isAcp || modeFromAcp || thoughtFromAcp) {
-        controls.push({
-            id: 'mode',
-            type: thoughtFromAcp ? 'cycle' : 'select',
-            label: thoughtFromAcp ? 'Thinking' : 'Mode',
-            icon: thoughtFromAcp ? '🧠' : '⚡',
-            placement: 'bar',
-            dynamic: !modeFromAcp && !thoughtFromAcp,
-            listScript: 'listModes',
-            setScript: thoughtFromAcp ? 'setThinkingLevel' : 'setMode',
-            readFrom: 'mode',
-            ...(modeFromAcp && {
-                options: acpModes!.map((m: any) => ({ value: m.id, label: m.name || m.id })),
-            }),
-            ...(thoughtFromAcp && {
-                options: thoughtFromAcp.options.map((o: any) => ({ value: o.value, label: o.name || o.value })),
-            }),
-        });
-    }
-
-    return controls;
-}
 
 const IDE_SESSION_CAPABILITIES: SessionCapability[] = [
     'read_chat',
@@ -242,11 +182,7 @@ function buildIdeWorkspaceSession(
         currentAutoApprove: state.currentAutoApprove,
         ...(includeSessionControls && {
             controlValues: state.controlValues,
-            providerControls: buildFallbackControls(
-                state.providerControls,
-                state.currentModel,
-                state.currentPlan
-            ),
+            providerControls: state.providerControls,
         }),
         errorMessage: state.errorMessage,
         errorReason: state.errorReason,
@@ -281,11 +217,7 @@ function buildExtensionAgentSession(
         currentPlan: ext.currentPlan,
         ...(includeSessionControls && {
             controlValues: ext.controlValues,
-            providerControls: buildFallbackControls(
-                ext.providerControls,
-                ext.currentModel,
-                ext.currentPlan
-            ),
+            providerControls: ext.providerControls,
         }),
         errorMessage: ext.errorMessage,
         errorReason: ext.errorReason,
@@ -327,9 +259,7 @@ function buildCliSession(state: CliProviderState, options: SessionEntryBuildOpti
         }),
         ...(includeSessionControls && {
             controlValues: state.controlValues,
-            providerControls: buildFallbackControls(
-                state.providerControls
-            ),
+            providerControls: state.providerControls,
         }),
         errorMessage: state.errorMessage,
         errorReason: state.errorReason,
@@ -362,13 +292,7 @@ function buildAcpSession(state: AcpProviderState, options: SessionEntryBuildOpti
             acpConfigOptions: state.acpConfigOptions,
             acpModes: state.acpModes,
             controlValues: state.controlValues,
-            providerControls: buildFallbackControls(
-                state.providerControls,
-                state.currentModel,
-                state.currentPlan,
-                state.acpConfigOptions,
-                state.acpModes
-            ),
+            providerControls: state.providerControls,
         }),
         errorMessage: state.errorMessage,
         errorReason: state.errorReason,

package/src/types.ts

@@ -27,8 +27,8 @@ export interface StatusResponse extends StatusReportPayload {
 
 export interface ChatMessage {
   role: string;       // 'user' | 'assistant' | 'system' | 'human'
-  /** Plain text (legacy) or rich content blocks (ACP standard) */
-  content: string | ContentBlock[];
+  /** Plain text (legacy) or canonical message parts */
+  content: string | MessagePart[];
   kind?: string;      // 'standard' | 'thought' | 'tool' | 'terminal' | 'system'
   id?: string;
   index?: number;
@@ -46,7 +46,7 @@ export interface ChatMessage {
 }
 
 // Re-export from contracts for convenience
-import type { ContentBlock, ToolCallInfo } from './providers/contracts.js';
+import type { MessagePart, ToolCallInfo } from './providers/contracts.js';
 
 // ── Extension Info ──