@adhdev/daemon-core 0.6.12 → 0.6.15

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> {
@@ -1055,7 +1055,7 @@ export class DevServer {
   private async handleScaffold(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
     const body = await this.readBody(req);
     const { type, name, category = 'ide', location = 'user',
-      cdpPorts, cli, processName, installPath, binary, extensionId, version } = body;
+      cdpPorts, cli, processName, installPath, binary, extensionId, version, osPaths, processNames } = body;
     if (!type || !name) {
       this.json(res, 400, { error: 'type and name required' });
       return;
@@ -1076,7 +1076,7 @@ export class DevServer {
     }
 
     try {
-      const result = genScaffoldFiles(type, name, category, { cdpPorts, cli, processName, installPath, binary, extensionId, version });
+      const result = genScaffoldFiles(type, name, category, { cdpPorts, cli, processName, installPath, binary, extensionId, version, osPaths, processNames });
       fs.mkdirSync(targetDir, { recursive: true });
       fs.writeFileSync(jsonPath, result['provider.json'], 'utf-8');
       const createdFiles = ['provider.json'];
@@ -1843,51 +1843,9 @@ export class DevServer {
 
     try {
       // 1. Collect DOM context
-      this.sendAutoImplSSE({ event: 'progress', data: { function: '_init', status: 'analyzing', message: 'DOM 구조 수집 중...' } });
-
-      let domContext: any = null;
-      const cdp = this.getCdp(type);
-      if (cdp) {
-        try {
-          const domScript = `(() => {
-            function fp(el) {
-              if (!el || el === document.body) return 'body';
-              const parts = [];
-              let c = el;
-              while (c && c !== document.documentElement) {
-                let s = c.tagName.toLowerCase();
-                if (c.id) s = '#' + c.id;
-                else if (c.className && typeof c.className === 'string') {
-                  const cls = c.className.trim().split(/\\s+/).filter(x => x && !x.startsWith('_')).slice(0, 2);
-                  if (cls.length) s += '.' + cls.join('.');
-                }
-                parts.unshift(s);
-                c = c.parentElement;
-              }
-              return parts.join(' > ');
-            }
-            const r = {};
-            // Content editables
-            r.editables = [...document.querySelectorAll('[contenteditable], textarea, input')].filter(e => e.offsetWidth > 0).slice(0, 10).map(e => ({
-              selector: fp(e), tag: e.tagName.toLowerCase(), ce: e.getAttribute('contenteditable'), role: e.getAttribute('role'), ph: e.getAttribute('placeholder')
-            }));
-            // Scroll containers
-            r.scrollContainers = [...document.querySelectorAll('div, section')].filter(e => {
-              const s = getComputedStyle(e); const b = e.getBoundingClientRect();
-              return (s.overflowY === 'auto' || s.overflowY === 'scroll') && b.height > 200 && e.children.length > 2;
-            }).slice(0, 5).map(e => ({ selector: fp(e), children: e.children.length, h: Math.round(e.getBoundingClientRect().height) }));
-            // Buttons
-            r.buttons = [...document.querySelectorAll('button, [role="button"]')].filter(e => e.offsetWidth > 0).slice(0, 20).map(e => ({
-              text: (e.textContent||'').trim().substring(0, 60), selector: fp(e), label: e.getAttribute('aria-label')
-            }));
-            return JSON.stringify(r);
-          })()`;
-          const raw = await cdp.evaluate(domScript, 10000);
-          domContext = typeof raw === 'string' ? JSON.parse(raw) : raw;
-        } catch (e: any) {
-          this.log(`DOM context collection failed (non-fatal): ${e.message}`);
-        }
-      }
+      // 1. Skip heavy DOM pre-parsing (Agent will use cURL to explore via CDP!)
+      this.sendAutoImplSSE({ event: 'progress', data: { function: '_init', status: 'analyzing', message: '에이전트 초기화 (DOM 탐색 권한 부여)...' } });
+      const domContext = null;
 
       // 2. Load reference scripts
       this.sendAutoImplSSE({ event: 'progress', data: { function: '_init', status: 'loading_reference', message: `레퍼런스 스크립트 로드 중 (${reference})...` } });
@@ -2065,94 +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');
         }
-        useStdin = true;
+        if (!args.includes('--skip-git-repo-check')) {
+          args.push('--skip-git-repo-check');
+        }
+        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}`;
       }
 
-      // 5.5. Check agent binary exists
-      const { execSync } = await import('child_process');
-      try {
-        execSync(`which ${command}`, { stdio: 'pipe' });
-      } catch {
-        try { fs.unlinkSync(promptFile); } catch { /* ignore */ }
-        this.json(res, 400, { error: `Agent binary '${command}' not found on PATH. Install it first: ${(agentProvider as any)?.install || 'check provider docs'}` });
-        return;
-      }
-
-      // 6. Spawn CLI agent via shell pipe (avoids Node.js stdin deadlock on large prompts)
-      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');
-      // Shell pipe: cat promptFile | command args...
-      // This avoids Node.js stdin buffer deadlock and ensures proper EOF signaling
-      const escapedArgs = args.map(a => `'${a.replace(/'/g, "'\\''")}'`).join(' ');
-      const shellCmd = `cat '${promptFile}' | ${command} ${escapedArgs}`;
-      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,
@@ -2273,6 +2327,7 @@ export class DevServer {
     lines.push('4. Always wrap in try-catch, return `JSON.stringify(result)`');
     lines.push('5. Do NOT modify `scripts.js` router — only edit individual `*.js` files');
     lines.push('6. All scripts run in the browser (CDP evaluate) — use DOM APIs only');
+    lines.push('7. **Cross-Platform Compatibility**: If you use ARIA labels that contain keyboard shortcuts (e.g., `Cascade (⌘L)`), you MUST use substring matches (`aria-label*="Cascade"`) or handle both macOS (`⌘`, `Cmd`) and Windows (`Ctrl`) so the script does not break on other operating systems.');
     lines.push('');
 
     // ── Output contracts ──
@@ -2300,42 +2355,40 @@ export class DevServer {
     lines.push('');
 
     // ── DevConsole API for verification ──
-    lines.push('## DevConsole API (for testing)');
-    lines.push(`The DevConsole is running at \`http://127.0.0.1:${DEV_SERVER_PORT}\`. Use these HTTP APIs to test your implementations.`);
+    lines.push('## YOU MUST EXPLORE THE DOM YOURSELF!');
+    lines.push('I have NOT provided you with the DOM snapshot. You MUST use your command-line tools to discover the IDE structure dynamically!');
     lines.push('');
-    lines.push('### Run a script against the live IDE');
+    lines.push('### 1. Evaluate JS to explore IDE DOM');
+    lines.push('Use cURL to run JavaScript inside the IDE:');
     lines.push('```bash');
-    lines.push(`curl -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/providers/${type}/scripts/run \\`);
+    lines.push(`curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/cdp/evaluate \\`);
     lines.push(`  -H "Content-Type: application/json" \\`);
-    lines.push(`  -d '{"script": "readChat"}'`);
-    lines.push('```');
-    lines.push('Replace `"readChat"` with any function name. For functions with params:');
-    lines.push('```bash');
-    lines.push(`curl -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/providers/${type}/scripts/run \\`);
-    lines.push(`  -H "Content-Type: application/json" \\`);
-    lines.push(`  -d '{"script": "sendMessage", "params": {"text": "hello"}}'`);
+    lines.push(`  -d '{"expression": "document.body.innerHTML.substring(0, 1000)", "ideType": "${type}"}'`);
     lines.push('```');
     lines.push('');
-    lines.push('### Evaluate raw JS in the IDE (CDP)');
-    lines.push('```bash');
-    lines.push(`curl -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/cdp/evaluate \\`);
-    lines.push(`  -H "Content-Type: application/json" \\`);
-    lines.push(`  -d '{"expression": "document.title", "ideType": "${type}"}'`);
-    lines.push('```');
-    lines.push('');
-    lines.push('### Reload provider (after editing files)');
+    lines.push('### 2. Test your generated function');
+    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('```');
-    lines.push('**IMPORTANT**: After editing script files, you MUST call reload before running scripts.');
     lines.push('');
-    lines.push('### Workflow: Edit → Reload → Test → Fix');
-    lines.push('1. Edit the `.js` file');
-    lines.push('2. `curl POST /api/providers/reload`');
-    lines.push(`3. \`curl POST /api/providers/${type}/scripts/run -d '{"script":"readChat"}'\``);
-    lines.push('4. Check the response — if error, fix and repeat from step 1');
+    lines.push('### Task Workflow');
+    lines.push('1. Write bash scripts to `curl` the CDP evaluate API above to find exactly where `.chat-message`, etc., are located.');
+    lines.push('2. Iteratively explore until you are confident in your selectors.');
+    lines.push('3. Edit the `.js` files using the selectors you discovered.');
+    lines.push('4. Reload providers and TEST your script via the API.');
+    lines.push('');
+    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('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('');
-    lines.push('Start NOW. Edit files, then test each one.');
+    lines.push('Start NOW. Do not ask for permission. Explore the DOM -> Code -> Test.');
 
     return lines.join('\n');
   }

package/src/daemon/scaffold-template.ts

@@ -18,6 +18,8 @@ export interface ScaffoldOptions {
   binary?: string;
   extensionId?: string;
   version?: string;
+  osPaths?: Record<string, string[]>;
+  processNames?: Record<string, string>;
 }
 
 export interface ScaffoldResult {
@@ -75,8 +77,13 @@ export function generateFiles(type: string, name: string, category: string, opts
   if (cli) meta.cli = cli;
   if (cdpPorts) meta.cdpPorts = cdpPorts;
   else if (!isExtension) meta.cdpPorts = [9222, 9223];
-  if (processName) meta.processNames = { darwin: processName };
-  if (installPath) meta.paths = { darwin: [installPath] };
+  
+  if (opts.processNames) meta.processNames = opts.processNames;
+  else if (processName) meta.processNames = { darwin: processName };
+  
+  if (opts.osPaths) meta.paths = opts.osPaths;
+  else if (installPath) meta.paths = { darwin: [installPath] };
+  
   if (isExtension) {
     meta.extensionId = extensionId || `publisher.${type}`;
     meta.extensionIdPattern = `${extensionId || type}`;