@adhdev/daemon-core 0.6.13 → 0.6.16

package/package.json

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

package/src/daemon/dev-server.ts

@@ -307,8 +307,8 @@ export class DevServer {
     }
   }
 
-  private async handleRunScript(type: string, req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
-    const body = await this.readBody(req);
+  private async handleRunScript(type: string, req: http.IncomingMessage, res: http.ServerResponse, parsedBody?: any): Promise<void> {
+    const body = parsedBody || await this.readBody(req);
     const { script: scriptName, params, ideType: scriptIdeType } = body;
 
     const provider = this.providerLoader.resolve(type);
@@ -495,7 +495,7 @@ export class DevServer {
       return;
     }
     // Delegate to handleRunScript
-    await this.handleRunScript(type, req, res);
+    await this.handleRunScript(type, req, res, body);
   }
 
   private async handleStatus(_req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
@@ -2023,85 +2023,190 @@ export class DevServer {
       // Strip interactive-only flags for auto-implement (non-interactive mode)
       const interactiveFlags = ['--yolo', '--interactive', '-i'];
       const baseArgs: string[] = [...(spawn.args || [])].filter((a: string) => !interactiveFlags.includes(a));
-      let args: string[];
-      let useStdin = true;
+
+      // 6. Construct the complete shell command per-agent
+      let shellCmd: string;
 
       if (command === 'claude') {
-        // Claude Code: --print mode, skip permissions for non-interactive auto-implement
-        args = [...baseArgs, '--print', '--dangerously-skip-permissions', '--add-dir', providerDir];
-        useStdin = true;
+        // Claude Code: --print mode, skip permissions, prompt via -p "$(cat file)"
+        const args = [...baseArgs, '--print', '--dangerously-skip-permissions', '--add-dir', providerDir];
+        const escapedArgs = args.map(a => `'${a.replace(/'/g, "'\\''")}'`).join(' ');
+        shellCmd = `${command} ${escapedArgs} -p "$(cat '${promptFile}')"`;
       } else if (command === 'gemini') {
-        // Gemini CLI: -p (non-interactive mode) with stdin piped prompt
-        // -p "" means "non-interactive mode, read prompt from stdin"
-        // -y for yolo (auto-approve all), -s false for no sandbox
-        args = [...baseArgs, '-p', '', '-y', '-s', 'false'];
-        if (model) {
-          args.push('-m', model);
+        // Gemini CLI: non-interactive prompt mode
+        // We can't use @file syntax (causes Parts object parsing bug) or $(cat) (arg too long).
+        // Solution: meta-prompt that tells Gemini to read the instructions file itself.
+        const args = [...baseArgs, '-y', '-s', 'false'];
+        if (model) args.push('-m', model);
+        const escapedArgs = args.map(a => `'${a.replace(/'/g, "'\\''")}'`).join(' ');
+        shellCmd = `${command} ${escapedArgs} -p "Read the file at ${promptFile} and follow ALL the instructions in it exactly. Do not ask questions, just execute."`;
+
+      } else if (command === 'codex') {
+        const args = ['exec', ...baseArgs];
+        if (!args.includes('--dangerously-bypass-approvals-and-sandbox')) {
+          args.push('--dangerously-bypass-approvals-and-sandbox');
+        }
+        if (!args.includes('--skip-git-repo-check')) {
+          args.push('--skip-git-repo-check');
         }
-        useStdin = true;
+        if (model) args.push('--model', model);
+        const escapedArgs = args.map(a => `'${a.replace(/'/g, "'\\''")}'`).join(' ');
+        const metaPrompt = `Read the file at ${promptFile} and follow ALL the instructions. Implement the specific function requested, then test it via CDP curl targeting 127.0.0.1:19280, wait for confirmation of success, and then close. DO NOT start working on other features not listed in the prompt constraint.`;
+        shellCmd = `${command} ${escapedArgs} "${metaPrompt}"`;
       } else {
-        // Codex CLI, etc: pipe prompt via stdin
-        args = [...baseArgs];
+        // Generic fallback: pipe prompt via stdin
+        const escapedArgs = baseArgs.map(a => `'${a.replace(/'/g, "'\\''")}'`).join(' ');
+        shellCmd = `cat '${promptFile}' | ${command} ${escapedArgs}`;
       }
 
-      // 6. Spawn CLI agent natively passing prompt via -p (avoids pipe deadlock)
-      this.sendAutoImplSSE({ event: 'progress', data: { function: '_init', status: 'spawning', message: `에이전트 실행 중: ${command} ${args.join(' ')} (prompt: ${prompt.length} chars)` } });
+      this.sendAutoImplSSE({ event: 'progress', data: { function: '_init', status: 'spawning', message: `에이전트 실행 중: ${shellCmd.substring(0, 200)}... (prompt: ${prompt.length} chars)` } });
 
       this.autoImplStatus = { running: true, type, progress: [] };
 
+      let child: any;
+      let isPty = false;
       const { spawn: spawnFn } = await import('child_process');
       
-      // Add prompt file text directly as an argument using cat evaluation in shell
-      // This completely bypasses massive stdin pipe blocking while retaining CLI formatting
-      const escapedArgs = args.map(a => `'${a.replace(/'/g, "'\\''")}'`).join(' ');
-      const shellCmd = `${command} ${escapedArgs} -p "$(cat '${promptFile}')"`;
-      this.log(`Auto-implement spawn: ${shellCmd}`);
-      const child = spawnFn('sh', ['-c', shellCmd], {
-        cwd: providerDir,
-        shell: false,
-        timeout: 900000, // 15 min timeout
-        stdio: ['ignore', 'pipe', 'pipe'],
-        env: { ...process.env, ...(spawn.env || {}) },
-      });
-      this.autoImplProcess = child;
-      child.on('error', (err) => {
-        this.log(`Auto-implement spawn error: ${err.message}`);
-        this.sendAutoImplSSE({ event: 'output', data: { chunk: `[Spawn Error] ${err.message}\n`, stream: 'stderr' } });
-      });
+      try {
+        const pty = require('node-pty');
+        this.log(`Auto-implement spawn (PTY): ${shellCmd}`);
+        const isWin = os.platform() === 'win32';
+        child = pty.spawn(isWin ? 'cmd.exe' : (process.env.SHELL || '/bin/zsh'), [isWin ? '/c' : '-c', shellCmd], {
+          name: 'xterm-256color',
+          cols: 120,
+          rows: 40,
+          cwd: providerDir,
+          env: { ...process.env, ...(spawn.env || {}) },
+        });
+        isPty = true;
+      } catch (err: any) {
+        this.log(`PTY not available, using child_process: ${err.message}`);
+        child = spawnFn('sh', ['-c', shellCmd], {
+          cwd: providerDir,
+          shell: false,
+          timeout: 900000,
+          stdio: ['pipe', 'pipe', 'pipe'],
+          env: { 
+            ...process.env, 
+            ...(spawn.env || {}),
+            ...(command === 'gemini' ? { SANDBOX: '1', GEMINI_CLI_NO_RELAUNCH: '1' } : {}),
+          },
+        });
+        child.on('error', (err: Error) => {
+          this.log(`Auto-implement spawn error: ${err.message}`);
+          this.sendAutoImplSSE({ event: 'output', data: { chunk: `[Spawn Error] ${err.message}\n`, stream: 'stderr' } });
+        });
+      }
 
+      this.autoImplProcess = child;
       let stdout = '';
       let stderr = '';
-      child.stdout?.on('data', (d: Buffer) => {
-        const chunk = d.toString();
-        stdout += chunk;
-        this.sendAutoImplSSE({ event: 'output', data: { chunk, stream: 'stdout' } });
-      });
-      child.stderr?.on('data', (d: Buffer) => {
-        const chunk = d.toString();
-        stderr += chunk;
-        this.sendAutoImplSSE({ event: 'output', data: { chunk, stream: 'stderr' } });
-      });
+      
+      let approvalPatterns: RegExp[] = [];
+      let approvalKeys: Record<number, string> = { 0: 'y\r' };
+      let approvalBuffer = '';
+      let lastApprovalTime = 0;
+      
+      try {
+        const { normalizeCliProviderForRuntime } = await import('../cli-adapters/provider-cli-adapter.js');
+        const normalized = normalizeCliProviderForRuntime(agentProvider);
+        approvalPatterns = normalized.patterns.approval;
+        approvalKeys = (agentProvider as any)?.approvalKeys || { 0: 'y\r', 1: 'a\r' };
+      } catch (err: any) {
+        this.log(`Failed to load approval patterns: ${err.message}`);
+      }
 
-      child.on('exit', (code) => {
-        this.autoImplProcess = null;
-        this.autoImplStatus.running = false;
-        const success = code === 0;
-        this.sendAutoImplSSE({
-          event: 'complete',
-          data: {
-            success,
-            exitCode: code,
-            functions,
-            message: success ? '✅ Auto-implement 완료' : `❌ 에이전트 종료 (code: ${code})`,
-          },
-        });
-        // Reload providers to pick up new scripts
-        try { this.providerLoader.reload(); } catch { /* ignore */ }
-        // Cleanup temp prompt file
-        try { fs.unlinkSync(promptFile); } catch { /* ignore */ }
-        this.log(`Auto-implement ${success ? 'completed' : 'failed'}: ${type} (exit: ${code})`);
-      });
+      const checkAutoApproval = (chunk: string, writeFn: (s: string) => void) => {
+        // Strip ANSI
+        const cleanData = chunk.replace(/\x1B\[\d*[A-HJKSTfG]/g, ' ')
+            .replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '')
+            .replace(/\x1B\][^\x07]*\x07/g, '')
+            .replace(/\x1B\][^\x1B]*\x1B\\/g, '')
+            .replace(/  +/g, ' ');
+            
+        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.');
+          this.sendAutoImplSSE({ event: 'output', data: { chunk: `\n[🤖 ADHDev Pipeline] Completion token detected. Proceeding...\n`, stream: 'stdout' } });
+          approvalBuffer = '';
+          
+          try {
+            (this.autoImplProcess as any).kill('SIGINT');
+          } catch {
+            // ignore
+          }
+          return;
+        }
+        
+        // Use a cooldown to prevent overlapping approval submissions
+        if (Date.now() - lastApprovalTime < 2000) return;
+        
+        if (approvalPatterns.some(p => p.test(approvalBuffer))) {
+          // Use 'Always allow' (1) if available, otherwise 'Allow once' (0), otherwise hard fallback to 'a\r' for newer CLIs
+          const key = approvalKeys[1] || approvalKeys[0] || 'a\r';
+          writeFn(key);
+          this.log(`Auto-Implement auto-approved prompt! Sending: ${JSON.stringify(key)}`);
+          this.sendAutoImplSSE({ event: 'output', data: { chunk: `\n[🤖 ADHDev Auto-Approve] CLI Action Approved\n`, stream: 'stdout' } });
+          approvalBuffer = '';
+          lastApprovalTime = Date.now();
+        }
+      };
 
+      if (isPty) {
+        child.onData((data: string) => {
+          stdout += data;
+          if (data.includes('\x1b[6n')) {
+            child.write('\x1b[12;1R');
+            this.log('Terminal CPR request (\\x1b[6n) intercepted in PTY, responding with dummy coordinates [12;1R]');
+          }
+          checkAutoApproval(data, (s) => child.write(s));
+          this.sendAutoImplSSE({ event: 'output', data: { chunk: data, stream: 'stdout' } });
+        });
+        child.onExit(({ exitCode: code }: { exitCode: number }) => {
+          this.autoImplProcess = null;
+          this.autoImplStatus.running = false;
+          const success = code === 0;
+          this.sendAutoImplSSE({
+            event: 'complete',
+            data: { success, exitCode: code, functions, message: success ? '✅ Auto-implement 완료' : `❌ 에이전트 종료 (code: ${code})` },
+          });
+          try { this.providerLoader.reload(); } catch { /* ignore */ }
+          try { fs.unlinkSync(promptFile); } catch { /* ignore */ }
+        });
+      } else {
+        child.stdout?.on('data', (d: Buffer) => {
+          const chunk = d.toString();
+          stdout += chunk;
+          if (chunk.includes('\x1b[6n')) child.stdin?.write('\x1b[1;1R');
+          checkAutoApproval(chunk, (s) => child.stdin?.write(s));
+          this.sendAutoImplSSE({ event: 'output', data: { chunk, stream: 'stdout' } });
+        });
+        child.stderr?.on('data', (d: Buffer) => {
+          const chunk = d.toString();
+          stderr += chunk;
+          checkAutoApproval(chunk, (s) => child.stdin?.write(s));
+          this.sendAutoImplSSE({ event: 'output', data: { chunk, stream: 'stderr' } });
+        });
+        child.on('exit', (code: number) => {
+          this.autoImplProcess = null;
+          this.autoImplStatus.running = false;
+          const success = code === 0;
+          this.sendAutoImplSSE({
+            event: 'complete',
+            data: {
+              success,
+              exitCode: code,
+              functions,
+              message: success ? '✅ Auto-implement 완료' : `❌ 에이전트 종료 (code: ${code})`,
+            },
+          });
+          try { this.providerLoader.reload(); } catch { /* ignore */ }
+          try { fs.unlinkSync(promptFile); } catch { /* ignore */ }
+          this.log(`Auto-implement ${success ? 'completed' : 'failed'}: ${type} (exit: ${code})`);
+        });
+      }
       this.json(res, 202, {
         started: true,
         type,

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

@@ -79,7 +79,12 @@ export class ProviderInstanceManager {
  // pending events propagation
                 for (const event of state.pendingEvents) {
                     for (const listener of this.eventListeners) {
-                        listener({ ...event, providerType: instance.type });
+                        listener({
+                            ...event,
+                            providerType: instance.type,
+                            instanceId: state.instanceId,
+                            providerCategory: state.category,
+                        });
                     }
                 }
             } catch (e) {