@adhdev/daemon-core 0.5.3

package/src/providers/contracts.ts

@@ -0,0 +1,524 @@
+/**
+ * Provider Output Contracts — Output contracts all providers must conform to
+ * 
+ * Design principles:
+ * - Only output format is standardized; implementation is free
+ * - Common across all categories (cli, ide, extension)
+ * - User custom providers use the same contracts
+ */
+
+// ─── readChat() return value ───────────────────────────
+
+export interface ReadChatResult {
+  messages: ChatMessage[];
+  status: AgentStatus;
+  activeModal?: ModalInfo | null;
+ /** IDE/Extension only: session info */
+  id?: string;
+  title?: string;
+ /** Extension only: additional metadata */
+  agentType?: string;
+  agentName?: string;
+  extensionId?: string;
+ /** Status metadata */
+  isVisible?: boolean;
+  isWelcomeScreen?: boolean;
+  inputContent?: string;
+  model?: string;
+  mode?: string;
+  autoApprove?: string;
+}
+
+export interface ChatMessage {
+  role: 'user' | 'assistant' | 'system';
+  /** Plain text (legacy) or rich content blocks (ACP standard) */
+  content: string | ContentBlock[];
+ /** Optional: unique message ID */
+  id?: string;
+ /** Optional: order index */
+  index?: number;
+ /** Optional: timestamp */
+  timestamp?: number;
+ /** Optional: receivedAt (assigned by daemon) */
+  receivedAt?: number;
+ /** Optional: tool calls associated with this message */
+  toolCalls?: ToolCallInfo[];
+ /** Optional: fiber metadata */
+  _type?: string;
+  _sub?: string;
+}
+
+export type AgentStatus = 
+  | 'idle' 
+  | 'generating' 
+  | 'waiting_approval' 
+  | 'error' 
+  | 'panel_hidden'
+  | 'streaming';
+
+export interface ModalInfo {
+  message: string;
+  buttons: string[];
+  width?: number;
+  height?: number;
+}
+
+// ─── Rich Content Types (ACP Standard) ─────────────────
+// Based on ACP SDK v0.16.1 schema types.
+// All provider categories (ACP, IDE, Extension, CLI) use these as output standard.
+
+/**
+ * ContentBlock — ACP ContentBlock union type
+ * Represents displayable content in messages, tool call results, etc.
+ */
+export type ContentBlock =
+  | TextBlock
+  | ImageBlock
+  | AudioBlock
+  | ResourceLinkBlock
+  | ResourceBlock;
+
+/** Text content — ACP TextContent */
+export interface TextBlock {
+  type: 'text';
+  text: string;
+  annotations?: ContentAnnotations;
+}
+
+/** Image content — ACP ImageContent */
+export interface ImageBlock {
+  type: 'image';
+  data: string;       // base64-encoded
+  mimeType: string;   // 'image/png', 'image/jpeg', etc.
+  uri?: string;       // optional URL reference
+  annotations?: ContentAnnotations;
+}
+
+/** Audio content — ACP AudioContent */
+export interface AudioBlock {
+  type: 'audio';
+  data: string;       // base64-encoded
+  mimeType: string;
+  annotations?: ContentAnnotations;
+}
+
+/** Resource link (file reference) — ACP ResourceLink */
+export interface ResourceLinkBlock {
+  type: 'resource_link';
+  uri: string;
+  name: string;
+  title?: string;
+  description?: string;
+  mimeType?: string;
+  size?: number;
+  annotations?: ContentAnnotations;
+}
+
+/** Embedded resource (inline file) — ACP EmbeddedResource */
+export interface ResourceBlock {
+  type: 'resource';
+  resource: TextResourceContents | BlobResourceContents;
+  annotations?: ContentAnnotations;
+}
+
+export interface TextResourceContents {
+  uri: string;
+  text: string;
+  mimeType?: string;
+}
+
+export interface BlobResourceContents {
+  uri: string;
+  blob: string;      // base64-encoded
+  mimeType?: string;
+}
+
+export interface ContentAnnotations {
+  audience?: ('user' | 'assistant')[];
+  priority?: number;  // 0.0 ~ 1.0
+}
+
+// ─── Tool Call Types (ACP Standard) ─────────────────────
+
+/** Tool call info — ACP ToolCall */
+export interface ToolCallInfo {
+  toolCallId: string;
+  title: string;
+  kind?: ToolKind;
+  status?: ToolCallStatus;
+  rawInput?: unknown;
+  rawOutput?: unknown;
+  content?: ToolCallContent[];
+  locations?: ToolCallLocation[];
+}
+
+export type ToolKind = 'read' | 'edit' | 'delete' | 'move' | 'search' | 'execute' | 'think' | 'fetch' | 'switch_mode' | 'other';
+export type ToolCallStatus = 'pending' | 'in_progress' | 'completed' | 'failed';
+
+/** Content produced by a tool call — ACP ToolCallContent */
+export type ToolCallContent =
+  | { type: 'content'; content: ContentBlock }
+  | { type: 'diff'; path: string; oldText?: string; newText: string }
+  | { type: 'terminal'; terminalId: string };
+
+export interface ToolCallLocation {
+  path: string;
+  line?: number;
+}
+
+// ─── Content Helpers ────────────────────────────────────
+
+/** Normalize content: string → ContentBlock[] */
+export function normalizeContent(content: string | ContentBlock[]): ContentBlock[] {
+  if (typeof content === 'string') {
+    return [{ type: 'text', text: content }];
+  }
+  return content;
+}
+
+/** Flatten ContentBlock[] → string (backward compat / plain-text extraction) */
+export function flattenContent(content: string | ContentBlock[]): string {
+  if (typeof content === 'string') return content;
+  return content
+    .filter((b): b is TextBlock => b.type === 'text')
+    .map(b => b.text)
+    .join('\n');
+}
+
+/** SendMessage params — supports rich content (ACP PromptRequest compatible) */
+export interface SendMessageParams {
+  /** Shortcut: text-only message */
+  text?: string;
+  /** Rich content blocks (ACP ContentBlock[]) */
+  prompt?: ContentBlock[];
+}
+
+// ─── sendMessage() return value ────────────────────────
+
+export interface SendMessageResult {
+  sent: boolean;
+  error?: string;
+ /** When CDP Input API is needed (Lexical editor etc) */
+  needsTypeAndSend?: boolean;
+  selector?: string;
+}
+
+// ─── listSessions() return value ───────────────────────
+
+export interface ListSessionsResult {
+  sessions: SessionInfo[];
+}
+
+export interface SessionInfo {
+  id: string;
+  title: string;
+  time?: string;
+}
+
+// ─── switchSession() return value ──────────────────────
+
+export interface SwitchSessionResult {
+  switched: boolean;
+ /** When CDP click coordinates are needed (Antigravity QuickInput etc) */
+  action?: 'click';
+  clickX?: number;
+  clickY?: number;
+  error?: string;
+}
+
+// ─── resolveAction() return value ──────────────────────
+// Two methods supported:
+
+/**
+ * Method 1: Script-Click — script calls el.click() directly
+ * Cursor Suitable for IDEs using div.cursor-pointer elements.
+ */
+export interface ResolveActionScriptClick {
+  resolved: boolean;        // true = click succeeded
+  clicked?: string;         // clicked button text
+  available?: string[];     // available buttons when resolved=false
+  error?: string;
+}
+
+/**
+ * Method 2: Coordinate-Click — returns coordinates, daemon performs CDP mouse click
+ * Antigravity Suitable for IDEs where el.click() does not work.
+ */
+export interface ResolveActionCoordinateClick {
+  found: boolean;           // true = button found
+  text?: string;            // button text
+  x?: number;               // click X coordinate
+  y?: number;               // click Y coordinate
+  w?: number;               // button width
+  h?: number;               // button height
+}
+
+export type ResolveActionResult = ResolveActionScriptClick | ResolveActionCoordinateClick;
+
+
+// ─── Provider Module type ────────────────────────
+
+export type ProviderCategory = 'cli' | 'ide' | 'extension' | 'acp';
+
+/**
+ * Type of object exported by module.exports in provider.js.
+ * 
+ * Each provider.js is fully independent and does not import other providers.
+ * Helpers (_helpers/) can be optionally used.
+ */
+/**
+ * Provider-configurable CDP target filter.
+ * Used by DaemonCdpManager to select the correct page/tab to connect to.
+ * Without this, the manager uses a hardcoded default filter.
+ */
+export interface CdpTargetFilter {
+ /** URL must include this string (e.g. 'workbench.html') */
+  urlIncludes?: string;
+ /** URL must NOT include any of these strings */
+  urlExcludes?: string[];
+ /** Page title regex pattern for titles to EXCLUDE (e.g. 'Debug Console|Output') */
+  titleExcludes?: string;
+}
+
+export interface ProviderModule {
+ /** Unique identifier (e.g. 'cline', 'cursor', 'gemini-cli') */
+  type: string;
+ /** Display name (e.g. 'Cline', 'Cursor') */
+  name: string;
+ /** Category: determines execution method */
+  category: ProviderCategory;
+ /** Alias list — allows users to invoke by alternate names (e.g. ['claude', 'claude-code']) */
+  aliases?: string[];
+
+ // ─── IDE infrastructure (used by launch/daemon) ───
+ /** CDP ports [primary, secondary] (IDE category only) */
+  cdpPorts?: [number, number];
+ /** CDP target filter — controls which page/tab to connect to (IDE category only) */
+  targetFilter?: CdpTargetFilter;
+ /** CLI command (e.g. 'cursor', 'code') */
+  cli?: string;
+ /** Display icon */
+  icon?: string;
+ /** Display name (short name) */
+  displayName?: string;
+ /** Install instructions (shown when command is missing) */
+  install?: string;
+ /** Custom version detection command (e.g. 'cursor --version', 'claude -v') */
+  versionCommand?: string;
+ /** Versions tested by provider maintainer (informational) */
+  testedVersions?: string[];
+ /** Per-OS process names — used by launch.ts to detect/kill IDE processes */
+  processNames?: {
+    darwin?: string;
+    win32?: string[];
+    linux?: string[];
+    [key: string]: string | string[] | undefined;
+  };
+ /** Per-OS install paths — used by detector.ts to detect IDE installation */
+  paths?: {
+    darwin?: string[];
+    win32?: string[];
+    linux?: string[];
+    [key: string]: string[] | undefined;
+  };
+
+ // ─── Extension category only ───
+  extensionId?: string;
+  extensionIdPattern?: RegExp;
+
+ // ─── CLI category only ───
+  binary?: string;
+  spawn?: {
+    command: string;
+    args?: string[];
+    shell?: boolean;
+    env?: Record<string, string>;
+  };
+  patterns?: {
+    prompt?: RegExp[];
+    generating?: RegExp[];
+    approval?: RegExp[];
+    ready?: RegExp[];
+  };
+  cleanOutput?: (raw: string, lastUserInput?: string) => string;
+
+ // ─── CDP scripts (ide/extension category) ───
+  scripts?: ProviderScripts;
+
+ // ─── VS Code Commands (Extension IPC via) ───
+  vscodeCommands?: {
+    focusPanel?: string;
+    openPanel?: string;
+    [key: string]: string | undefined;
+  };
+
+ // ─── Input method (IDE category — Lexical editor etc) ───
+  inputMethod?: 'cdp-type-and-send' | 'script';
+  inputSelector?: string;
+
+ // ─── Webview chat (IDE category — chat UI is in webview iframe) ───
+ /** webview iframe match text (must be contained in body) */
+  webviewMatchText?: string;
+
+ // ─── Per-OS overrides ───
+  os?: {
+    [platform: string]: Partial<Pick<ProviderModule, 'scripts' | 'inputMethod' | 'inputSelector'>>;
+  };
+
+ // ─── Per-version overrides ───
+  /** Key: semver range string (e.g. '< 1.107.0', '>= 2.0.0') */
+  versions?: {
+    [versionRange: string]: Partial<Pick<ProviderModule, 'scripts'>> & {
+      /**
+       * Load scripts from a subdirectory instead of scripts.js root.
+       * Path is relative to the provider directory (e.g. 'scripts/legacy').
+       * The subdirectory should contain its own scripts.js or individual .js files.
+       */
+      __dir?: string;
+    };
+  };
+
+ // ─── Composite override (OS + version) ───
+  overrides?: Array<{
+    when: { os?: string; version?: string };
+    scripts?: Partial<ProviderScripts>;
+    /** Load scripts from a subdirectory for this OS+version combination */
+    __dir?: string;
+  }>;
+
+ // ─── Provider Settings (variables controllable from dashboard) ───
+  settings?: Record<string, ProviderSettingDef>;
+
+ // ─── ACP Static Config (for agents without config/* support) ───
+ /** Static options used when agent does not provide configOptions */
+  staticConfigOptions?: Array<{
+    category: 'model' | 'mode' | 'thought_level' | 'other';
+    configId: string;
+    defaultValue?: string;
+    options: Array<{ value: string; name: string; description?: string; group?: string }>;
+  }>;
+ /** Function to convert selected config values to spawn args (applied via process restart when config/* not supported) */
+  spawnArgBuilder?: (config: Record<string, string>) => string[];
+
+ // ─── ACP Authentication (auth method definitions) ───
+ /** ACP agent auth methods (multiple supported — in priority order) */
+  auth?: AcpAuthMethod[];
+}
+
+// ─── ACP Auth Types ─────────────────────────────────
+
+/** ACP auth method — based on ACP official spec */
+export type AcpAuthMethod = AcpAuthEnvVar | AcpAuthAgent | AcpAuthTerminal;
+
+/** Environment variable-based auth (API keys etc) */
+export interface AcpAuthEnvVar {
+  type: 'env_var';
+  id: string;
+  name: string;
+  vars: Array<{
+    name: string;
+    label?: string;
+    secret?: boolean;    // default true
+    optional?: boolean;  // default false
+  }>;
+  link?: string;  // Key issuance URL
+}
+
+/** Agent self-auth (OAuth, browser-based etc) */
+export interface AcpAuthAgent {
+  type: 'agent';
+  id: string;
+  name: string;
+  description?: string;
+}
+
+/** Terminal command-based auth (runs setup command) */
+export interface AcpAuthTerminal {
+  type: 'terminal';
+  id: string;
+  name: string;
+  description?: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+/**
+ * CDP script functions.
+ * Each function takes a params object and returns a JS code string for CDP evaluate.
+ * The JS execution result must conform to the Output Contract.
+ * 
+ * Custom scripts can be added via index signature in addition to built-in scripts.
+ * All scripts can receive params: Record<string, any>,
+ * backward compatible with legacy single-argument style (e.g. sendMessage(text)).
+ */
+export interface ProviderScripts {
+ // ─── Core ───
+  readChat?: (params?: Record<string, any>) => string;
+  sendMessage?: (params?: Record<string, any>) => string;
+  listSessions?: (params?: Record<string, any>) => string;
+  switchSession?: (params?: Record<string, any>) => string;
+  newSession?: (params?: Record<string, any>) => string;
+
+ // ─── UI Control ───
+  focusEditor?: (params?: Record<string, any>) => string;
+  openPanel?: (params?: Record<string, any>) => string;
+
+ // ─── Model / Mode Control ───
+ /** List available models → { models: string[], current: string } */
+  listModels?: (params?: Record<string, any>) => string;
+ /** Change model → { success: boolean } */
+  setModel?: (params?: Record<string, any>) => string;
+ /** List available modes → { modes: string[], current: string } */
+  listModes?: (params?: Record<string, any>) => string;
+ /** Change mode → { success: boolean } */
+  setMode?: (params?: Record<string, any>) => string;
+
+ // ─── Modal/Approval ───
+ /** params: { action: 'approve'|'reject'|'custom', button?: string } */
+  resolveAction?: (params?: Record<string, any>) => string;
+
+ // ─── Notifications ───
+  listNotifications?: (params?: Record<string, any>) => string;
+  dismissNotification?: (params?: Record<string, any>) => string;
+
+ // ─── Custom Scripts (user-defined) ───
+  [scriptName: string]: ((params?: Record<string, any>) => string) | undefined;
+}
+
+
+/**
+ * ProviderLoader.resolve() result: Final provider with OS/version overrides applied
+ */
+export interface ResolvedProvider extends ProviderModule {
+ /** OS applied during resolve */
+  _resolvedOs?: string;
+ /** Version applied during resolve */
+  _resolvedVersion?: string;
+ /** Warning when detected version is not in compatibility matrix */
+  _versionWarning?: string;
+}
+
+// ─── Provider Settings ─────────────────────────────────
+
+/** Setting variable definition declared by provider */
+export interface ProviderSettingDef {
+  type: 'boolean' | 'number' | 'string' | 'select';
+  default: any;
+ /** true = controllable from dashboard UI */
+  public: boolean;
+ /** UI label */
+  label?: string;
+ /** UI description */
+  description?: string;
+ /** Minimum value for number type */
+  min?: number;
+ /** Maximum value for number type */
+  max?: number;
+ /** Options for select type */
+  options?: string[];
+}
+
+/** Public settings schema (for dashboard transmission) */
+export interface ProviderSettingSchema extends ProviderSettingDef {
+  key: string;
+}

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

@@ -0,0 +1,156 @@
+/**
+ * ExtensionProviderInstance — Runtime instance for Extension Provider
+ *
+ * Manages IDE extensions (Cline, Roo Code, etc).
+ * CDP webview discovery + agent stream collection moved here.
+ */
+
+import type { ProviderModule } from './contracts.js';
+import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext } from './provider-instance.js';
+import { StatusMonitor } from './status-monitor.js';
+
+export class ExtensionProviderInstance implements ProviderInstance {
+    readonly type: string;
+    readonly category = 'extension' as const;
+
+    private provider: ProviderModule;
+    private context: InstanceContext | null = null;
+    private settings: Record<string, any> = {};
+    private events: ProviderEvent[] = [];
+
+ // status
+    private currentStatus: string = 'idle';
+    private agentStreams: any[] = [];
+    private messages: any[] = [];
+    private activeModal: any = null;
+    private lastAgentStatus: string = 'idle';
+    private generatingStartedAt: number = 0;
+    private monitor: StatusMonitor;
+
+ // meta
+    private instanceId: string;
+    private ideType: string = '';
+
+    constructor(provider: ProviderModule) {
+        this.type = provider.type;
+        this.provider = provider;
+        this.instanceId = crypto.randomUUID();
+        this.monitor = new StatusMonitor();
+    }
+
+ // ─── Lifecycle ──────────────────────────────────
+
+    async init(context: InstanceContext): Promise<void> {
+        this.context = context;
+        this.settings = context.settings || {};
+        this.monitor.updateConfig({
+            approvalAlert: this.settings.approvalAlert !== false,
+            longGeneratingAlert: this.settings.longGeneratingAlert !== false,
+            longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180,
+        });
+    }
+
+    async onTick(): Promise<void> {
+ // Extension gets data pushed from IDE's CDP agent stream
+ // Needed when direct stream collection via CDP is possible
+        if (!this.context?.cdp?.isConnected) return;
+
+ // Agent stream collect (CDP discoverAgentWebviews etc)
+ // Currently handled separately by agent-stream-manager only
+ // Can be moved here in the future
+    }
+
+    getState(): ProviderState {
+        return {
+            type: this.type,
+            name: this.provider.name,
+            category: 'extension',
+            status: this.currentStatus as ProviderState['status'],
+            activeChat: this.messages.length > 0 ? {
+                id: `${this.type}_session`,
+                title: this.provider.name,
+                status: this.currentStatus,
+                messages: this.messages,
+                activeModal: this.activeModal,
+                inputContent: '',
+            } : null,
+            agentStreams: this.agentStreams,
+            instanceId: this.instanceId,
+            lastUpdated: Date.now(),
+            settings: this.settings,
+            pendingEvents: this.flushEvents(),
+        };
+    }
+
+    onEvent(event: string, data?: any): void {
+        if (event === 'stream_update') {
+ // Reflect data collected from agent-stream-manager
+            if (data?.streams) this.agentStreams = data.streams;
+            if (data?.messages) this.messages = data.messages;
+            if (data?.status) {
+                const newStatus = data.status;
+                this.detectTransition(newStatus, data);
+                this.currentStatus = newStatus;
+            }
+        } else if (event === 'extension_connected') {
+            this.ideType = data?.ideType || '';
+ // Maintain instanceId UUID — do not overwrite
+        }
+    }
+
+    dispose(): void {
+        this.agentStreams = [];
+        this.messages = [];
+        this.monitor.reset();
+    }
+
+ /** Query UUID instanceId */
+    getInstanceId(): string {
+        return this.instanceId;
+    }
+
+ // ─── status transition detect ──────────────────────────────
+
+    private detectTransition(newStatus: string, data: any): void {
+        const now = Date.now();
+        const agentStatus = (newStatus === 'streaming' || newStatus === 'generating') ? 'generating'
+            : newStatus === 'waiting_approval' ? 'waiting_approval'
+            : 'idle';
+
+        if (agentStatus !== this.lastAgentStatus) {
+            const chatTitle = this.provider.name;
+
+            if (this.lastAgentStatus === 'idle' && agentStatus === 'generating') {
+                this.generatingStartedAt = now;
+                this.pushEvent({ event: 'agent:generating_started', chatTitle, timestamp: now });
+            } else if (agentStatus === 'waiting_approval') {
+                if (!this.generatingStartedAt) this.generatingStartedAt = now;
+                this.pushEvent({ event: 'agent:waiting_approval', chatTitle, timestamp: now });
+            } else if (agentStatus === 'idle' && (this.lastAgentStatus === 'generating' || this.lastAgentStatus === 'waiting_approval')) {
+                const duration = this.generatingStartedAt ? Math.round((now - this.generatingStartedAt) / 1000) : 0;
+                this.pushEvent({ event: 'agent:generating_completed', chatTitle, duration, timestamp: now });
+                this.generatingStartedAt = 0;
+            }
+
+            this.lastAgentStatus = agentStatus;
+        }
+
+ // Monitor check (cooldown based notification)
+        const agentKey = `${this.type}:ext`;
+        const monitorEvents = this.monitor.check(agentKey, agentStatus, now);
+        for (const me of monitorEvents) {
+            this.pushEvent({ event: me.type, agentKey: me.agentKey, message: me.message, elapsedSec: me.elapsedSec, timestamp: me.timestamp });
+        }
+    }
+
+    private pushEvent(event: ProviderEvent): void {
+        this.events.push(event);
+        if (this.events.length > 50) this.events = this.events.slice(-50);
+    }
+
+    private flushEvents(): ProviderEvent[] {
+        const events = [...this.events];
+        this.events = [];
+        return events;
+    }
+}