editormate 0.0.0-stage → 1.0.2

package/extension/src/extension.ts

@@ -0,0 +1,458 @@
+import * as vscode from 'vscode';
+import * as http from 'http';
+import * as os from 'os';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as child_process from 'child_process';
+import { EditorMateViewProvider } from './sidebar_provider';
+import { getRealIdeName } from './ide_detector';
+
+export function activate(context: vscode.ExtensionContext) {
+  // 0. Check Companion Daemon health
+  ensureDaemonRunning(context);
+
+  // 1. Bottom Status Bar Item (Click directly opens sidebar)
+  const savedIcon = context.globalState.get<string>('editormate.icon') || 'remote';
+  const statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 100);
+  statusBar.text = `$(${savedIcon}) EditorMate`;
+  statusBar.tooltip = 'EditorMate — Companion Status & Workflow Monitor • Click to open sidebar';
+  statusBar.command = 'editormate.openSidebar';
+  statusBar.show();
+  context.subscriptions.push(statusBar);
+
+  // 2. Webview Control Panel Provider (Activity Bar & Explorer Sidebar)
+  const provider = new EditorMateViewProvider(context.extensionUri, context);
+  provider.setStatusBarItem(statusBar);
+  context.subscriptions.push(
+    vscode.window.registerWebviewViewProvider('editormate.controlPanel', provider, {
+      webviewOptions: { retainContextWhenHidden: true }
+    }),
+    vscode.window.registerWebviewViewProvider('editormate.explorerPanel', provider, {
+      webviewOptions: { retainContextWhenHidden: true }
+    })
+  );
+
+  // 3. Helper: Route incoming mobile message directly to the desired chat surface
+  async function dispatchToIdeAgent(text: string, autoSubmit: boolean = false): Promise<boolean> {
+    try {
+      const allCmds = new Set(await vscode.commands.getCommands(true));
+
+      // 1. Antigravity IDE Native AI Agent Panel
+      if (allCmds.has('antigravity.sendPromptToAgentPanel')) {
+        if (allCmds.has('antigravity.openAgent')) {
+          try { await vscode.commands.executeCommand('antigravity.openAgent'); } catch {}
+        }
+        await vscode.commands.executeCommand('antigravity.sendPromptToAgentPanel', text);
+        return true;
+      }
+
+      // 2. Cursor IDE Chat
+      if (allCmds.has('cursor.chat')) {
+        await vscode.commands.executeCommand('cursor.chat', text);
+        return true;
+      }
+
+      // 3. VS Code Copilot Chat
+      if (allCmds.has('workbench.action.chat.open')) {
+        await vscode.commands.executeCommand('workbench.action.chat.open', {
+          query: text,
+          isPartialQuery: !autoSubmit
+        });
+        if (autoSubmit) {
+          setTimeout(async () => {
+            try { await vscode.commands.executeCommand('workbench.action.chat.submit'); } catch {}
+          }, 150);
+        }
+        return true;
+      }
+
+      // 4. Quick Chat fallback
+      if (allCmds.has('workbench.action.quickchat.toggle')) {
+        await vscode.commands.executeCommand('workbench.action.quickchat.toggle');
+        return true;
+      }
+    } catch {}
+    return false;
+  }
+
+  function cleanIncomingPrompt(raw: string): string {
+    if (!raw) return '';
+    let text = raw;
+    const userReq = text.match(/<USER_REQUEST>([\s\S]*?)<\/USER_REQUEST>/i);
+    if (userReq) text = userReq[1];
+    text = text.replace(/<ADDITIONAL_METADATA>[\s\S]*?<\/ADDITIONAL_METADATA>/gi, '');
+    text = text.replace(/<ADDITIONAL_METADATA>[\s\S]*$/gi, '');
+    text = text.replace(/<\/?(USER_REQUEST|ADDITIONAL_METADATA|USER_SETTINGS_CHANGE|SYSTEM_MESSAGE)[^>]*>/gi, '');
+    text = text.replace(/The user has uploaded \d+ audio file\(s\)\. Consider them as a part of their message\./gi, '');
+    return text.trim();
+  }
+
+  async function routeMessageToChat(rawText: string, sender: string, forcedRouting?: string) {
+    const text = cleanIncomingPrompt(rawText) || rawText;
+    const config = vscode.workspace.getConfiguration('editormate');
+    const mode = forcedRouting || 
+      context.globalState.get<string>('editormate.chatRouting') || 
+      config.get<string>('chatRouting', 'autoPin');
+
+    // 1. Always copy to clipboard for instant pasting anywhere
+    try {
+      await vscode.env.clipboard.writeText(text);
+    } catch {}
+
+    // 2. Insert into active text editor if configured
+    if (mode === 'insertEditor') {
+      const activeEditor = vscode.window.activeTextEditor;
+      if (activeEditor) {
+        activeEditor.edit((builder) => {
+          builder.insert(activeEditor.selection.active, text);
+        });
+      }
+    }
+
+    // 3. Direct injection into active AI chat surface (clean message only)
+    const agentPayload = text;
+    const injected = await dispatchToIdeAgent(agentPayload, mode === 'autoSubmit');
+
+    // 4. Interactive Notification Toast
+    const preview = text.length > 60 ? text.substring(0, 57) + '...' : text;
+    vscode.window.showInformationMessage(
+      `📱 Mobile [${sender}]: ${preview}`,
+      '💬 Send to Agent',
+      '📝 Insert in Editor',
+      '📋 Copy'
+    ).then(async (action) => {
+      if (action === '💬 Send to Agent') {
+        await dispatchToIdeAgent(text, true);
+      } else if (action === '📝 Insert in Editor') {
+        const editor = vscode.window.activeTextEditor;
+        if (editor) {
+          editor.edit((builder) => {
+            builder.insert(editor.selection.active, text);
+          });
+        } else {
+          vscode.window.showWarningMessage('No active editor open to insert text.');
+        }
+      } else if (action === '📋 Copy') {
+        await vscode.env.clipboard.writeText(text);
+      }
+    });
+  }
+
+  async function resolvePendingIdeApprovals(type: 'allow' | 'allow_conversation' | 'allow_all' | 'deny'): Promise<void> {
+    try {
+      // 0. Resolve any active CommandGuard prompt promises
+      await provider.guard.resolvePendingExecution(type === 'deny' ? 'deny' : (type === 'allow_all' ? 'allow_all' : 'allow'));
+
+      // 1. If allow_all, update execution guard mode
+      if (type === 'allow_all') {
+        try { await provider.guard.setApprovalMode('allow_all'); } catch {}
+      }
+
+      if (type === 'allow' || type === 'allow_conversation' || type === 'allow_all') {
+        // 2. Cross-IDE Native Commands (Antigravity, Cursor, VS Code, Windsurf)
+        try { await vscode.commands.executeCommand('notifications.acceptPrimaryAction'); } catch {}
+        try { await vscode.commands.executeCommand('workbench.action.modalConfirmation.confirm'); } catch {}
+        try { await vscode.commands.executeCommand('workbench.action.acceptSelectedQuickOpenItem'); } catch {}
+
+        vscode.window.setStatusBarMessage(`📱 EditorMate: Approved pending security dialog (${type}) via remote mobile command`, 4000);
+      } else if (type === 'deny') {
+        try { await vscode.commands.executeCommand('workbench.action.modalConfirmation.cancel'); } catch {}
+        try { await vscode.commands.executeCommand('notifications.hideToasts'); } catch {}
+
+        vscode.window.setStatusBarMessage('📱 EditorMate: Denied pending prompt via remote mobile command', 4000);
+      }
+    } catch (err: any) {
+      console.error('[EditorMate] Error resolving IDE approvals:', err);
+    }
+  }
+
+  // 4. Register VS Code Commands
+  context.subscriptions.push(
+    vscode.commands.registerCommand('editormate.openSidebar', () => {
+      vscode.commands.executeCommand('editormate.controlPanel.focus');
+    }),
+    vscode.commands.registerCommand('editormate.status', async () => {
+      vscode.commands.executeCommand('editormate.controlPanel.focus');
+    }),
+    vscode.commands.registerCommand('editormate.changeIcon', async () => {
+      await provider.remoteActions.triggerChangeIcon(statusBar);
+    }),
+    vscode.commands.registerCommand('editormate.terminal', async () => {
+      await provider.remoteActions.triggerRemoteTerminal();
+    }),
+    vscode.commands.registerCommand('editormate.connectTelegram', () => {
+      provider.remoteActions.triggerPairing('telegram');
+    }),
+    vscode.commands.registerCommand('editormate.connectDiscord', () => {
+      provider.remoteActions.triggerPairing('discord');
+    }),
+    vscode.commands.registerCommand('editormate.connectWhatsApp', () => {
+      provider.remoteActions.triggerPairing('whatsapp');
+    }),
+    vscode.commands.registerCommand('editormate.enterLicense', async () => {
+      await provider.remoteActions.triggerEnterLicense();
+    }),
+    vscode.commands.registerCommand('editormate.renameDevice', async () => {
+      await provider.remoteActions.triggerRenameDevice();
+    }),
+    vscode.commands.registerCommand('editormate.manageAliases', async () => {
+      await provider.commandsManager.promptManageAliases();
+    }),
+    vscode.commands.registerCommand('editormate.addAlias', async () => {
+      await provider.commandsManager.promptAddAlias();
+    }),
+    vscode.commands.registerCommand('editormate.enableCompanionService', async () => {
+      await startCompanionDaemon(context, true);
+      setTimeout(() => provider.refresh(), 1200);
+    }),
+    vscode.commands.registerCommand('editormate.startDaemon', async () => {
+      await startCompanionDaemon(context, true);
+      setTimeout(() => provider.refresh(), 1200);
+    })
+  );
+
+  // 5. Background Remote Inbox Stream & Session Sync
+  const processedMessageIds = new Set<string>();
+  let activeTargetSessionId = '';
+  const mySessionId = provider.getMySessionId();
+  const extensionStartTime = Date.now();
+
+  const pollInterval = setInterval(() => {
+    http.get('http://127.0.0.1:4588/api/inbox', (res) => {
+      let data = '';
+      res.on('data', (c) => (data += c));
+      res.on('end', async () => {
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed.activeSessionId) {
+            activeTargetSessionId = parsed.activeSessionId;
+          }
+          if (parsed.success && Array.isArray(parsed.messages) && parsed.messages.length > 0) {
+            provider.updateCachedInbox(parsed.messages);
+
+            // Filter all unseen messages and mark as processed
+            const unseen = parsed.messages.filter((m: any) => m && m.id && !processedMessageIds.has(m.id));
+            for (const m of unseen) {
+              processedMessageIds.add(m.id);
+            }
+
+            // Only dispatch unseen messages arriving after or close to extension start (within 30s)
+            const freshMessages = unseen
+              .filter((m: any) => (m.timestamp || 0) > (extensionStartTime - 30000))
+              .reverse(); // Route chronologically
+
+            for (const newest of freshMessages) {
+              // CRITICAL: TARGET IDE CHECK
+              // If only 1 session is connected or activeTarget matches, route here
+              const designatedTarget = newest.targetSessionId || activeTargetSessionId;
+              const isTargetActive = designatedTarget ? designatedTarget === mySessionId : true;
+
+              if (isTargetActive) {
+                const rawTrimmed = (newest.text || '').trim().toLowerCase();
+                if (
+                  rawTrimmed === '1' ||
+                  rawTrimmed === '1.' ||
+                  rawTrimmed === '/1' ||
+                  rawTrimmed === '/allow' ||
+                  rawTrimmed === 'allow' ||
+                  rawTrimmed === '/approve' ||
+                  rawTrimmed === 'approve' ||
+                  rawTrimmed === '/yes' ||
+                  rawTrimmed === 'yes' ||
+                  rawTrimmed === '/ok' ||
+                  rawTrimmed === 'ok'
+                ) {
+                  await resolvePendingIdeApprovals('allow');
+                } else if (
+                  rawTrimmed === '2' ||
+                  rawTrimmed === '2.' ||
+                  rawTrimmed === '/2' ||
+                  rawTrimmed === '/allow_conversation' ||
+                  rawTrimmed === 'allow conversation'
+                ) {
+                  await resolvePendingIdeApprovals('allow_conversation');
+                } else if (
+                  rawTrimmed === '3' ||
+                  rawTrimmed === '3.' ||
+                  rawTrimmed === '/3' ||
+                  rawTrimmed === '/allowall' ||
+                  rawTrimmed === '/allow_all' ||
+                  rawTrimmed === 'allow all' ||
+                  rawTrimmed === 'allowall' ||
+                  rawTrimmed === '/whitelist' ||
+                  rawTrimmed === 'always'
+                ) {
+                  await resolvePendingIdeApprovals('allow_all');
+                } else if (
+                  rawTrimmed === '4' ||
+                  rawTrimmed === '4.' ||
+                  rawTrimmed === '/4' ||
+                  rawTrimmed === '/deny' ||
+                  rawTrimmed === 'deny' ||
+                  rawTrimmed === '/reject' ||
+                  rawTrimmed === 'reject' ||
+                  rawTrimmed === '/no' ||
+                  rawTrimmed === 'no' ||
+                  rawTrimmed === '/cancel'
+                ) {
+                  await resolvePendingIdeApprovals('deny');
+                } else {
+                  await routeMessageToChat(newest.text, newest.sender);
+                }
+              }
+            }
+            if (unseen.length > 0) {
+              provider.refresh();
+            }
+          }
+        } catch {}
+      });
+    }).on('error', () => {
+      ensureDaemonRunning(context);
+    });
+
+    // Session Sync: Synchronize custom shortcuts with daemon and check for pending remote executions
+    try {
+      const wsFolder = vscode.workspace.workspaceFolders?.[0];
+      const wsName = wsFolder?.name || 'editormate';
+      const wsPath = wsFolder?.uri.fsPath || '';
+      const shortcuts = context.globalState.get<any[]>('editormate.customShortcuts') || [];
+      const syncPayload = JSON.stringify({
+        sessionId: mySessionId,
+        workspaceName: wsName,
+        workspacePath: wsPath,
+        ideType: getRealIdeName(),
+        customShortcuts: shortcuts,
+      });
+
+      const sReq = http.request(
+        'http://127.0.0.1:4588/api/session/sync',
+        {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Content-Length': Buffer.byteLength(syncPayload)
+          }
+        },
+        (sRes) => {
+          let sBuf = '';
+          sRes.on('data', (c) => (sBuf += c));
+          sRes.on('end', () => {
+            try {
+              const sJson = JSON.parse(sBuf);
+              if (sJson.success) {
+                if (sJson.activeSessionId) {
+                  activeTargetSessionId = sJson.activeSessionId;
+                }
+                provider.updateDaemonStatus(sJson);
+                if (sJson.pendingExecutionCommand) {
+                  provider.guard.requestExecution(sJson.pendingExecutionCommand, undefined, 'Connected Mobile Device');
+                }
+              }
+            } catch {}
+          });
+        }
+      );
+      sReq.on('error', () => {});
+      sReq.write(syncPayload);
+      sReq.end();
+    } catch {}
+
+    // Also fetch status to keep licensing and target WA number up to date
+    try {
+      http.get('http://127.0.0.1:4588/api/status', (res) => {
+        let buf = '';
+        res.on('data', (c) => (buf += c));
+        res.on('end', () => {
+          try {
+            const st = JSON.parse(buf);
+            if (st.status === 'OK') {
+              if (st.activeSessionId) activeTargetSessionId = st.activeSessionId;
+              provider.updateDaemonStatus(st);
+            }
+          } catch {}
+        });
+      }).on('error', () => {});
+    } catch {}
+  }, 2500);
+
+  context.subscriptions.push({ dispose: () => clearInterval(pollInterval) });
+}
+
+export function ensureDaemonRunning(context: vscode.ExtensionContext, interactive: boolean = false) {
+  const req = http.get('http://127.0.0.1:4588/health', () => {});
+  req.on('error', () => {
+    const autoStart = context.globalState.get<boolean>('editormate.autoStartService');
+    if (autoStart) {
+      startCompanionDaemon(context, false);
+      return;
+    }
+    const promptShown = context.globalState.get<boolean>('editormate.enablePromptShown');
+    if (!promptShown || interactive) {
+      context.globalState.update('editormate.enablePromptShown', true);
+      vscode.window.showInformationMessage(
+        '📱 EditorMate: Local companion service is required to render Telegram/WhatsApp QR codes & stream window frames.',
+        '⚡ Enable Companion Service',
+        'Later'
+      ).then(async (selection) => {
+        if (selection === '⚡ Enable Companion Service') {
+          await context.globalState.update('editormate.autoStartService', true);
+          await startCompanionDaemon(context, true);
+        }
+      });
+    }
+  });
+  req.setTimeout(800, () => req.destroy());
+}
+
+export async function startCompanionDaemon(context: vscode.ExtensionContext, interactive: boolean = false): Promise<boolean> {
+  const candidates = [
+    path.join(context.extensionPath, 'bin', 'cli.js'),
+    path.join(context.extensionPath, 'daemon', 'bin', 'cli.js'),
+    path.join(context.extensionPath, 'daemon', 'index.js'),
+    path.join(context.extensionPath, '..', 'bin', 'cli.js'),
+    path.join(os.homedir(), 'Desktop', 'work', 'portfolio-engine', 'ai-tools', 'editormate', 'bin', 'cli.js'),
+  ];
+  const target = candidates.find((t) => fs.existsSync(t));
+  const isWin = process.platform === 'win32';
+  const env = { ...process.env, ELECTRON_RUN_AS_NODE: '1' };
+
+  if (target) {
+    try {
+      const child = child_process.spawn('node', [target, 'daemon'], {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: isWin,
+        env,
+      });
+      child.on('error', () => {
+        try {
+          const fallbackChild = child_process.spawn(process.execPath, [target, 'daemon'], {
+            detached: true,
+            stdio: 'ignore',
+            windowsHide: isWin,
+            env,
+          });
+          fallbackChild.unref();
+        } catch {
+          const term = vscode.window.createTerminal({ name: 'EditorMate Companion' });
+          term.sendText(`node "${target}" daemon`);
+        }
+      });
+      child.unref();
+      if (interactive) {
+        vscode.window.setStatusBarMessage('🚀 EditorMate: Companion service launched on port 4588', 3500);
+      }
+      return true;
+    } catch {
+      const term = vscode.window.createTerminal({ name: 'EditorMate Companion' });
+      term.sendText(`node "${target}" daemon`);
+      return true;
+    }
+  } else {
+    const term = vscode.window.createTerminal({ name: 'EditorMate Companion' });
+    term.sendText('npx editormate daemon || editormate daemon');
+    return true;
+  }
+}
+

package/extension/src/ide_detector.ts

@@ -0,0 +1,60 @@
+import * as vscode from 'vscode';
+
+/**
+ * Returns the actual IDE application name where this extension is running.
+ * Dynamic and accurate across VS Code, Cursor, Antigravity, Windsurf, VSCodium, etc.
+ */
+export function getRealIdeName(): string {
+  const appName = vscode.env.appName || '';
+  if (/antigravity/i.test(appName)) return 'Antigravity';
+  if (/cursor/i.test(appName)) return 'Cursor';
+  if (/windsurf/i.test(appName)) return 'Windsurf';
+  if (/codium/i.test(appName)) return 'VSCodium';
+  if (/code/i.test(appName)) return 'VS Code';
+  return appName || 'VS Code';
+}
+
+/**
+ * Validates that an account is a genuine, authenticated paired companion device.
+ * Excludes test mock accounts, test handles, fake 555 numbers, and WhatsApp group JIDs.
+ */
+export function isRealPairedAccount(a: any): boolean {
+  if (!a || !a.userId || !a.platform) return false;
+  const uid = String(a.userId).trim();
+  const handle = String(a.userHandle || '').trim().toLowerCase();
+
+  const mockIds = new Set([
+    'tg_test_user_777',
+    '777123',
+    'disc_user_555',
+    'u_slack_dev_123',
+    'u12345678',
+    '8979609593',
+    'test_user',
+    'mock_user',
+    'dummy_user',
+    '14155552671',
+    '23201547579578',
+  ]);
+  if (mockIds.has(uid.toLowerCase())) return false;
+  if (/^(test_|mock_|dummy_|fake_)/i.test(uid)) return false;
+  if (/^(devtester|telegramhacker|discordgamer|@slackdeveloper)$/i.test(handle)) return false;
+
+  // Filter mock 555 phone numbers
+  if (/\b555\d{4}\b/.test(uid)) return false;
+
+  // Filter WhatsApp groups
+  if (uid.includes('@g.us') || uid.startsWith('120363')) return false;
+
+  return ['whatsapp', 'telegram', 'discord', 'slack', 'matrix'].includes(a.platform);
+}
+
+/**
+ * Checks whether an IDE is currently active in this workspace context.
+ */
+export function isHostIdeRunning(ide: string): boolean {
+  const norm = (ide || '').toLowerCase();
+  const currentIde = getRealIdeName().toLowerCase();
+  return currentIde.includes(norm) || norm.includes(currentIde);
+}
+