@adhdev/daemon-core 0.6.19 → 0.6.22

package/package.json

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

package/src/boot/daemon-lifecycle.ts

@@ -93,13 +93,16 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
     // 1. Global log interceptor
     installGlobalInterceptor();
 
-    // 2. ProviderLoader
+    // 2. ProviderLoader (disableUpstream from config.json)
+    const appConfig = loadConfig();
+    const disableUpstream = appConfig.disableUpstream ?? false;
     const providerLoader = new ProviderLoader({
         logFn: config.providerLogFn,
+        disableUpstream,
     });
 
     // If no upstream providers exist, fetch them first (blocking — critical for new users)
-    if (!providerLoader.hasUpstream()) {
+    if (!disableUpstream && !providerLoader.hasUpstream()) {
         LOG.info('Provider', 'No upstream providers found — downloading from GitHub...');
         try {
             await providerLoader.fetchLatest();

package/src/commands/handler.ts

@@ -369,6 +369,12 @@ export class DaemonCommandHandler implements CommandHelpers {
             case 'list_extension_modes': return Stream.handleExtensionScript(this, args, 'listModes');
             case 'set_extension_mode': return Stream.handleExtensionScript(this, args, 'setMode');
 
+            // ─── Provider Auto-Fix / Clone (DevServer proxy) ──────────
+            case 'provider_auto_fix': return this.proxyDevServerPost(args, 'auto-implement');
+            case 'provider_auto_fix_cancel': return this.proxyDevServerPost(args, 'auto-implement/cancel');
+            case 'provider_auto_fix_status': return this.proxyDevServerGet(args, 'auto-implement/status');
+            case 'provider_clone': return this.proxyDevServerScaffold(args);
+
             default:
                 return { success: false, error: `Unknown command: ${cmd}` };
         }
@@ -398,4 +404,83 @@ export class DaemonCommandHandler implements CommandHelpers {
         }
         return { success: false, error: 'ProviderLoader not initialized' };
     }
+
+    // ─── DevServer HTTP proxy helpers ─────────────────
+    // These bridge WS commands to the DevServer REST API (localhost:19280)
+
+    private async proxyDevServerPost(args: any, endpoint: string): Promise<CommandResult> {
+        const { providerType, ...body } = args || {};
+        if (!providerType) return { success: false, error: 'providerType required' };
+        try {
+            const http = await import('http');
+            const postData = JSON.stringify(body);
+            const result = await new Promise<any>((resolve, reject) => {
+                const req = http.request({
+                    hostname: '127.0.0.1', port: 19280,
+                    path: `/api/providers/${providerType}/${endpoint}`,
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(postData) },
+                }, (res) => {
+                    let data = '';
+                    res.on('data', (chunk: Buffer) => data += chunk);
+                    res.on('end', () => {
+                        try { resolve(JSON.parse(data)); } catch { resolve({ raw: data }); }
+                    });
+                });
+                req.on('error', reject);
+                req.write(postData);
+                req.end();
+            });
+            return { success: true, ...result };
+        } catch (e: any) {
+            return { success: false, error: `DevServer unreachable: ${e.message}. Start daemon with --dev flag.` };
+        }
+    }
+
+    private async proxyDevServerGet(args: any, endpoint: string): Promise<CommandResult> {
+        const { providerType } = args || {};
+        if (!providerType) return { success: false, error: 'providerType required' };
+        try {
+            const http = await import('http');
+            const result = await new Promise<any>((resolve, reject) => {
+                http.get(`http://127.0.0.1:19280/api/providers/${providerType}/${endpoint}`, (res) => {
+                    let data = '';
+                    res.on('data', (chunk: Buffer) => data += chunk);
+                    res.on('end', () => {
+                        try { resolve(JSON.parse(data)); } catch { resolve({ raw: data }); }
+                    });
+                }).on('error', reject);
+            });
+            return { success: true, ...result };
+        } catch (e: any) {
+            return { success: false, error: `DevServer unreachable: ${e.message}. Start daemon with --dev flag.` };
+        }
+    }
+
+    private async proxyDevServerScaffold(args: any): Promise<CommandResult> {
+        try {
+            const http = await import('http');
+            const postData = JSON.stringify(args || {});
+            const result = await new Promise<any>((resolve, reject) => {
+                const req = http.request({
+                    hostname: '127.0.0.1', port: 19280,
+                    path: '/api/scaffold',
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(postData) },
+                }, (res) => {
+                    let data = '';
+                    res.on('data', (chunk: Buffer) => data += chunk);
+                    res.on('end', () => {
+                        try { resolve(JSON.parse(data)); } catch { resolve({ raw: data }); }
+                    });
+                });
+                req.on('error', reject);
+                req.write(postData);
+                req.end();
+            });
+            return { success: true, ...result };
+        } catch (e: any) {
+            return { success: false, error: `DevServer unreachable: ${e.message}. Start daemon with --dev flag.` };
+        }
+    }
 }

package/src/config/config.ts

@@ -67,6 +67,9 @@ export interface ADHDevConfig {
  // Stable machine ID (prevents duplicate daemon entries when OS hostname changes dynamically)
     machineId?: string;
 
+ // Machine secret for server auth (replaces connectionToken)
+    machineSecret?: string | null;
+
  // CLI launch history
     cliHistory: CliHistoryEntry[];
 
@@ -77,6 +80,10 @@ export interface ADHDevConfig {
     ideSettings: Record<string, {
         extensions?: Record<string, { enabled: boolean }>;
     }>;
+
+ // Disable upstream provider auto-download (use builtin only)
+ // Controllable from CLI (--no-upstream) and dashboard (machine page)
+    disableUpstream?: boolean;
 }
 
 export interface CliHistoryEntry {
@@ -108,9 +115,11 @@ const DEFAULT_CONFIG: ADHDevConfig = {
     recentWorkspaceActivity: [],
     machineNickname: null,
     machineId: undefined,
+    machineSecret: null,
     cliHistory: [],
     providerSettings: {},
     ideSettings: {},
+    disableUpstream: false,
 };
 
 /**

package/src/daemon/dev-server.ts

@@ -1824,7 +1824,7 @@ export class DevServer {
 
   private async handleAutoImplement(type: string, req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
     const body = await this.readBody(req);
-    const { agent = 'claude-cli', functions, reference = 'antigravity', model } = body;
+    const { agent = 'claude-cli', functions, reference = 'antigravity', model, comment } = body;
     if (!functions || !Array.isArray(functions) || functions.length === 0) {
       this.json(res, 400, { error: 'functions[] is required (e.g. ["readChat", "sendMessage"])' });
       return;
@@ -1874,7 +1874,7 @@ export class DevServer {
       }
 
       // 3. Build the prompt
-      const prompt = this.buildAutoImplPrompt(type, provider, providerDir, functions, domContext, referenceScripts);
+      const prompt = this.buildAutoImplPrompt(type, provider, providerDir, functions, domContext, referenceScripts, comment);
 
       // 4. Write prompt to temp file (avoids shell escaping issues with special chars)
       const tmpDir = path.join(os.tmpdir(), 'adhdev-autoimpl');
@@ -2064,6 +2064,7 @@ export class DevServer {
       this.sendAutoImplSSE({ event: 'progress', data: { function: '_init', status: 'spawning', message: `에이전트 실행 중: ${shellCmd.substring(0, 200)}... (prompt: ${prompt.length} chars)` } });
 
       this.autoImplStatus = { running: true, type, progress: [] };
+      const spawnedAt = Date.now();
 
       let child: any;
       let isPty = false;
@@ -2128,9 +2129,10 @@ export class DevServer {
             
         approvalBuffer = (approvalBuffer + cleanData).slice(-1500);
         
-        // Force exit on completion signal
-        if (approvalBuffer.includes('AUTO_IMPLEMENT_FINISHED')) {
-          this.log('Agent finished task. Terminating interactive CLI session to unblock pipeline.');
+        // Force exit on completion signal (ignore during first 15s — prompt echo contains the token)
+        const elapsed = Date.now() - spawnedAt;
+        if (elapsed > 15000 && approvalBuffer.includes('AUTO_IMPLEMENT_FINISHED')) {
+          this.log(`Agent finished task after ${Math.round(elapsed/1000)}s. Terminating interactive CLI session to unblock pipeline.`);
           this.sendAutoImplSSE({ event: 'output', data: { chunk: `\n[🤖 ADHDev Pipeline] Completion token detected. Proceeding...\n`, stream: 'stdout' } });
           approvalBuffer = '';
           
@@ -2231,6 +2233,7 @@ export class DevServer {
     functions: string[],
     domContext: any,
     referenceScripts: Record<string, string>,
+    userComment?: string,
   ): string {
     const lines: string[] = [];
 
@@ -2350,6 +2353,24 @@ export class DevServer {
     lines.push('| openPanel | `{ opened: true/false }` |');
     lines.push('');
 
+    // ── readChat.status lifecycle spec ──
+    lines.push('## 🔴 CRITICAL: readChat `status` Lifecycle');
+    lines.push('The `status` field in readChat controls how the dashboard and daemon auto-approve-loop behave.');
+    lines.push('Getting this wrong will break the entire automation pipeline. The status MUST reflect the ACTUAL current state:');
+    lines.push('');
+    lines.push('| Status | When to use | How to detect |');
+    lines.push('|---|---|---|');
+    lines.push('| `idle` | AI is NOT generating, no approval needed | Default state. No stop button, no spinners, no approval pills/buttons |');
+    lines.push('| `generating` | AI is actively streaming/thinking | ANY of: (1) Stop/Cancel button visible, (2) CSS animation (animate-spin/pulse/bounce), (3) floating state text like Thinking/Generating/Sailing, (4) streaming indicator class |');
+    lines.push('| `waiting_approval` | AI stopped and needs user action | Actionable buttons like Run/Skip/Accept/Reject are visible AND clickable |');
+    lines.push('');
+    lines.push('### ⚠️ Status Detection Gotchas (MUST READ!)');
+    lines.push('1. **FALSE POSITIVES from old messages**: Chat history may contain text like "Command Awaiting Approval" from PAST turns. If you search the entire chat panel for this text, you will get false matches from parent divs whose innerText includes ALL child text. ONLY match small leaf elements (under 80 chars) or use explicit button/pill selectors.');
+    lines.push('2. **Awaiting Approval pill without actions**: Some IDEs show a floating pill/banner saying "Awaiting Approval" that is just a scroll-to indicator (not an actual approval dialog). If this pill exists but NO actionable buttons (Run/Skip/Accept/Reject) exist anywhere in the panel, the status should be `idle`, NOT `waiting_approval`.');
+    lines.push('3. **generating detection must be multi-signal**: Do NOT rely on just one indicator. Check ALL of: stop buttons, CSS animations, floating state labels, streaming classes. IDEs differ widely.');
+    lines.push('4. **activeModal must include actions**: When `status` is `waiting_approval`, the `activeModal` object MUST include a non-empty `actions` array listing the button labels. If you cannot find any action buttons, the status is NOT `waiting_approval`.');
+    lines.push('');
+
     lines.push('## Action');
     lines.push('1. Edit the script files to implement working code');
     lines.push('2. After editing, TEST each function using the DevConsole API (see below)');
@@ -2376,7 +2397,7 @@ export class DevServer {
     lines.push('Once you save the file, test it by running:');
     lines.push('```bash');
     lines.push(`curl -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/providers/reload`);
-    lines.push(`curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/providers/${type}/scripts/run -H "Content-Type: application/json" -d '{"script": "readChat"}'`);
+    lines.push(`curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/scripts/run -H "Content-Type: application/json" -d '{"script": "readChat", "type": "${type}", "ideType": "${type}"}'`);
     lines.push('```');
     lines.push('');
     lines.push('### Task Workflow');
@@ -2388,12 +2409,55 @@ export class DevServer {
     lines.push('### 🔥 Advanced UI Parsing (CRUCIAL for `readChat`)');
     lines.push('Your `readChat` must flawlessly parse complex UI elements (tables, code blocks, tool calls, and AI thoughts). The quality must match the `antigravity` reference.');
     lines.push('To achieve this, you MUST generate a live test scenario:');
-    lines.push('1. Early in your process, send a rich prompt to the IDE using the API:');
-    lines.push('   `curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/providers/${type}/scripts/run -H "Content-Type: application/json" -d \'{"script": "sendMessage", "params": {"text": "Write a python script, draw a markdown table, use a tool, and show your reasoning/thought process"}}\'`');
+    lines.push(`1. Early in your process, send a rich prompt to the IDE using the API:`);
+    lines.push(`   \`curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/scripts/run -H "Content-Type: application/json" -d '{"script": "sendMessage", "type": "${type}", "ideType": "${type}", "args": {"message": "Write a python script, draw a markdown table, use a tool, and show your reasoning/thought process"}}'\``);
     lines.push('2. Wait a few seconds for the IDE AI to generate these elements in the UI.');
     lines.push('3. Use CDP evaluate to deeply inspect the DOM structure of the newly generated tables, code blocks, thought blocks, and tool calls.');
     lines.push('4. Ensure `readChat` extracts `content` with precise markdown formatting (especially for tables/code) and assigns correct `kind` tags (`thought`, `tool`, `terminal`).');
     lines.push('');
+
+    // ── Mandatory Integration Test ──
+    lines.push('## 🧪 MANDATORY: Status Integration Test');
+    lines.push('Before finishing, you MUST run this end-to-end test to verify readChat status transitions work:');
+    lines.push('');
+    lines.push('### Step 1: Baseline — confirm idle');
+    lines.push('```bash');
+    lines.push(`curl -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/providers/reload`);
+    lines.push(`RESULT=$(curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/scripts/run -H "Content-Type: application/json" -d '{"script": "readChat", "type": "${type}", "ideType": "${type}"}')`);
+    lines.push(`echo "$RESULT" | python3 -c "import sys,json; d=json.load(sys.stdin); r=d.get('result',d); r=json.loads(r) if isinstance(r,str) else r; assert r.get('status')=='idle', f'Expected idle, got {r.get(chr(34)+chr(115)+chr(116)+chr(97)+chr(116)+chr(117)+chr(115)+chr(34))}'; print('Step 1 PASS: status=idle')"`);
+    lines.push('```');
+    lines.push('');
+    lines.push('### Step 2: Send a message that triggers generation');
+    lines.push('```bash');
+    lines.push(`curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/scripts/run -H "Content-Type: application/json" -d '{"script": "sendMessage", "type": "${type}", "ideType": "${type}", "args": {"message": "Say hello in one word"}}'`);
+    lines.push('sleep 2');
+    lines.push('```');
+    lines.push('');
+    lines.push('### Step 3: Check generating OR completed');
+    lines.push('The AI may still be generating OR may have finished already. Either generating or idle is acceptable:');
+    lines.push('```bash');
+    lines.push(`RESULT=$(curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/scripts/run -H "Content-Type: application/json" -d '{"script": "readChat", "type": "${type}", "ideType": "${type}"}')`);
+    lines.push(`echo "$RESULT" | python3 -c "import sys,json; d=json.load(sys.stdin); r=d.get('result',d); r=json.loads(r) if isinstance(r,str) else r; s=r.get('status'); assert s in ('generating','idle','waiting_approval'), f'Unexpected: {s}'; print(f'Step 3 PASS: status={s}')"`);
+    lines.push('```');
+    lines.push('');
+    lines.push('### Step 4: Wait for completion and verify new message');
+    lines.push('```bash');
+    lines.push('sleep 10');
+    lines.push(`RESULT=$(curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/scripts/run -H "Content-Type: application/json" -d '{"script": "readChat", "type": "${type}", "ideType": "${type}"}')`);
+    lines.push(`echo "$RESULT" | python3 -c "import sys,json; d=json.load(sys.stdin); r=d.get('result',d); r=json.loads(r) if isinstance(r,str) else r; s=r.get('status'); msgs=r.get('messages',[]); assert s=='idle', f'Expected idle, got {s}'; assert len(msgs)>0, 'No messages'; print(f'Step 4 PASS: status={s}, messages={len(msgs)}')"`);
+    lines.push('```');
+    lines.push('');
+    lines.push('If ANY step fails, fix your implementation and re-run the test. Do NOT finish until all 4 steps pass.');
+    lines.push('');
+    // ── User-provided additional instructions ──
+    if (userComment) {
+      lines.push('## ⚠️ User Instructions (HIGH PRIORITY)');
+      lines.push('The user has provided the following additional instructions. Follow them strictly:');
+      lines.push('');
+      lines.push(userComment);
+      lines.push('');
+    }
+
     lines.push('Start NOW. Do not ask for permission. Explore the DOM -> Code -> Test.');
 
     return lines.join('\n');

package/src/providers/provider-loader.ts

@@ -32,6 +32,7 @@ export class ProviderLoader {
   private builtinDirs: string[];
   private userDir: string;
   private upstreamDir: string;
+  private disableUpstream: boolean;
   private watchers: fs.FSWatcher[] = [];
   private logFn: (msg: string) => void;
   private versionArchive: VersionArchive | null = null;
@@ -49,6 +50,8 @@ export class ProviderLoader {
     builtinDir?: string | string[];
     userDir?: string;
     logFn?: (msg: string) => void;
+    /** Disable upstream auto-download (for dev/testing/OSS) */
+    disableUpstream?: boolean;
   }) {
  // Builtin directories: providers/_builtin/
     if (options?.builtinDir) {
@@ -61,6 +64,7 @@ export class ProviderLoader {
       path.join(os.homedir(), '.adhdev', 'providers');
  // Upstream auto-download directory: ~/.adhdev/providers/.upstream/
     this.upstreamDir = path.join(this.userDir, '.upstream');
+    this.disableUpstream = options?.disableUpstream ?? false;
     this.logFn = options?.logFn || LOG.forComponent('Provider').asLogFn();
   }
 
@@ -82,11 +86,13 @@ export class ProviderLoader {
 
  // 1. Load upstream (GitHub auto-download — primary source)
     let upstreamCount = 0;
-    if (fs.existsSync(this.upstreamDir)) {
+    if (!this.disableUpstream && fs.existsSync(this.upstreamDir)) {
       upstreamCount = this.loadDir(this.upstreamDir);
       if (upstreamCount > 0) {
         this.log(`Loaded ${upstreamCount} upstream providers (auto-updated)`);
       }
+    } else if (this.disableUpstream) {
+      this.log('Upstream loading disabled (disableUpstream=true)');
     }
 
  // 2. Load user custom (excluding .upstream — highest priority, never auto-updated)
@@ -547,6 +553,10 @@ export class ProviderLoader {
  * @returns Whether an update occurred
  */
   async fetchLatest(): Promise<{ updated: boolean; error?: string }> {
+    if (this.disableUpstream) {
+      this.log('Upstream fetch skipped (disableUpstream=true)');
+      return { updated: false };
+    }
     const https = require('https') as typeof import('https');
     const { execSync } = require('child_process') as typeof import('child_process');
 

package/src/status/reporter.ts

@@ -25,13 +25,14 @@ import type {
 export interface StatusReporterDeps {
     serverConn: { isConnected(): boolean; sendMessage(type: string, data: any): void; getUserPlan(): string } | null;
     cdpManagers: Map<string, { isConnected: boolean }>;
-    p2p: { isConnected: boolean; isAvailable: boolean; connectionState: string; connectedPeerCount: number; screenshotActive: boolean; sendStatus(data: any): void; sendStatusEvent?(event: Record<string, unknown>): boolean } | null;
+    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;
     daemonVersion?: string;
     instanceManager: { collectAllStates(): ProviderState[]; collectStatesByCategory(cat: string): ProviderState[] };
+    getScreenshotUsage?: () => { dailyUsedMinutes: number; dailyBudgetMinutes: number; budgetExhausted: boolean } | null;
 }
 
 export class DaemonStatusReporter {
@@ -100,13 +101,6 @@ export class DaemonStatusReporter {
         LOG.info('StatusEvent', `${event.event} (${event.providerType || event.ideType || ''})`);
         // Send via WS (server relay → dashboard + push notifications)
         this.deps.serverConn?.sendMessage('status_event', event);
-        // Also send via P2P (direct → dashboard, works even when WS is flaky)
-        // Frontend dedup prevents duplicate toasts
-        if (this.deps.p2p?.isConnected) {
-            try {
-                this.deps.p2p.sendStatusEvent?.(event);
-            } catch { /* P2P send failure is non-critical */ }
-        }
     }
 
     removeAgentTracking(_key: string): void { /* Managed by Instance itself */ }
@@ -206,6 +200,7 @@ export class DaemonStatusReporter {
                 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) => ({