editormate 0.0.0-stage → 1.0.2

package/extension/src/sidebar_provider.ts

@@ -0,0 +1,471 @@
+/**
+ * EditorMate — Sidebar Webview Provider
+ * Lightweight coordinator managing webview lifecycle, commands, and security guards.
+ */
+
+import * as vscode from 'vscode';
+import * as os from 'os';
+import * as http from 'http';
+import { generateWebviewHtml } from './webview_template';
+import { CommandGuard, ApprovalMode } from './command_guard';
+import { CommandsManager, SupportedCommand, IdeCustomSlot } from './commands_manager';
+import { RemoteActions } from './remote_actions';
+import { getRealIdeName, isRealPairedAccount, isHostIdeRunning } from './ide_detector';
+
+export class EditorMateViewProvider implements vscode.WebviewViewProvider {
+  private _views = new Set<vscode.WebviewView>();
+  private _statusBarItem?: vscode.StatusBarItem;
+  public readonly guard: CommandGuard;
+  public readonly commandsManager: CommandsManager;
+  public readonly remoteActions: RemoteActions;
+
+  constructor(
+    private readonly _extensionUri: vscode.Uri,
+    private readonly _context: vscode.ExtensionContext
+  ) {
+    this.guard = new CommandGuard(this._context);
+    this.commandsManager = new CommandsManager(this._context);
+    this.remoteActions = new RemoteActions(
+      this._context,
+      () => this.refresh(),
+      (msg) => this.broadcastMessage(msg)
+    );
+  }
+
+  private _cachedDaemonStatus: any = null;
+  private _cachedInbox: any[] = [];
+  private _activeMainTab: 'dashboard' | 'settings' = 'dashboard';
+
+  public setStatusBarItem(item: vscode.StatusBarItem) {
+    this._statusBarItem = item;
+  }
+
+  public getMySessionId(): string {
+    const wsFolder = vscode.workspace.workspaceFolders?.[0];
+    const wsName = wsFolder?.name || 'editormate';
+    return `session_${wsName.replace(/[^a-zA-Z0-9_-]/g, '_')}`;
+  }
+
+  public broadcastMessage(message: any) {
+    for (const view of this._views) {
+      view.webview.postMessage(message);
+    }
+  }
+
+  public updateCachedInbox(messages: any[]) {
+    this._cachedInbox = messages || [];
+    this.broadcastMessage({ command: 'updateFeed', messages: this._cachedInbox });
+  }
+
+  public updateDaemonStatus(status: any) {
+    this._cachedDaemonStatus = status;
+  }
+
+  public async resolveWebviewView(
+    webviewView: vscode.WebviewView,
+    _resolveContext: vscode.WebviewViewResolveContext,
+    _token: vscode.CancellationToken
+  ) {
+    this._views.add(webviewView);
+
+    webviewView.webview.options = {
+      enableScripts: true,
+      localResourceRoots: [this._extensionUri],
+    };
+
+    webviewView.webview.html = await this.getHtml();
+
+    webviewView.onDidDispose(() => {
+      this._views.delete(webviewView);
+    });
+
+    webviewView.webview.onDidReceiveMessage(async (data) => {
+      switch (data.command) {
+        case 'pair':
+          await this.remoteActions.triggerPairing(data.platform);
+          break;
+        case 'openUrl':
+          if (data.url) vscode.env.openExternal(vscode.Uri.parse(data.url));
+          break;
+        case 'updateSlot':
+          if (data.slotIndex && data.alias && data.targetCommand) {
+            await this.commandsManager.updateSlot(data.slotIndex, data.alias, data.targetCommand);
+            this.refresh();
+          }
+          break;
+        case 'addAlias':
+          if (data.alias && data.targetCommand) {
+            await this.commandsManager.addAlias(data.alias, data.targetCommand);
+            this.refresh();
+          }
+          break;
+        case 'editAlias':
+          if (data.oldAlias && data.newAlias && data.targetCommand) {
+            await this.commandsManager.editAlias(data.oldAlias, data.newAlias, data.targetCommand);
+            this.refresh();
+          }
+          break;
+        case 'runAlias':
+          if (data.alias) {
+            const cmd = this.commandsManager.findCommandByAlias(data.alias);
+            if (cmd) {
+              if (cmd.startsWith('/')) {
+                await this.handleRemoteCommand(cmd);
+              } else {
+                await this.guard.requestExecution(cmd, data.alias, 'Sidebar Alias Button');
+              }
+            }
+          }
+          break;
+        case 'deleteAlias':
+          if (data.alias) {
+            await this.commandsManager.removeAlias(data.alias);
+            this.refresh();
+          }
+          break;
+        case 'manageAliases':
+          await this.commandsManager.promptManageAliases();
+          this.refresh();
+          break;
+        case 'configureSlots':
+          await this.commandsManager.promptConfigureAllSlots();
+          this.refresh();
+          break;
+        case 'setThisIdeActive':
+          await this.remoteActions.triggerSetActiveSession(this.getMySessionId());
+          this.refresh();
+          break;
+        case 'setActiveCompanion':
+        case 'setSelectedCompanion':
+          if (data.companion) {
+            await this._context.globalState.update('editormate.selectedCompanion', data.companion);
+            vscode.window.setStatusBarMessage(`🎯 EditorMate: Active Companion ${data.companion}`, 3000);
+            this.refresh();
+          }
+          break;
+        case 'setActiveSession':
+          if (data.sessionId) {
+            await this.remoteActions.triggerSetActiveSession(data.sessionId);
+            this.refresh();
+          }
+          break;
+        case 'unpairAccount':
+          if (data.platform) {
+            // Eagerly update cached status so UI responds immediately
+            if (this._cachedDaemonStatus && Array.isArray(this._cachedDaemonStatus.linkedAccounts)) {
+              this._cachedDaemonStatus.linkedAccounts = this._cachedDaemonStatus.linkedAccounts.filter((a: any) => {
+                if (data.userId) {
+                  return !(a.platform === data.platform && (a.userId === data.userId || a.userId.endsWith(data.userId) || data.userId.endsWith(a.userId)));
+                }
+                return a.platform !== data.platform;
+              });
+            }
+            if (data.platform === 'whatsapp' && this._cachedDaemonStatus) {
+              this._cachedDaemonStatus.targetUserWaNumber = undefined;
+            }
+            const curComp = this._context.globalState.get<string>('editormate.selectedCompanion');
+            if (curComp && (curComp.startsWith(data.platform + ':') || curComp === data.platform)) {
+              await this._context.globalState.update('editormate.selectedCompanion', '');
+            }
+            this.refresh();
+
+            try {
+              const payload = JSON.stringify({ platform: data.platform, userId: data.userId });
+              const uReq = http.request('http://127.0.0.1:4588/api/account/unpair', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) }
+              }, (uRes) => {
+                let uBuf = '';
+                uRes.on('data', (c) => (uBuf += c));
+                uRes.on('end', () => {
+                  try {
+                    const uJson = JSON.parse(uBuf);
+                    if (uJson.linkedAccounts) {
+                      this._cachedDaemonStatus = { ...(this._cachedDaemonStatus || {}), linkedAccounts: uJson.linkedAccounts };
+                    }
+                  } catch {}
+                  this.refresh();
+                });
+              });
+              uReq.on('error', () => { this.refresh(); });
+              uReq.write(payload);
+              uReq.end();
+            } catch {
+              this.refresh();
+            }
+            vscode.window.setStatusBarMessage(`🔌 EditorMate: Unpaired ${data.platform} companion`, 3000);
+          }
+          break;
+        case 'setTargetWaNumber':
+          await this.remoteActions.triggerSetTargetWaNumber(data.phone);
+          this.refresh();
+          break;
+        case 'setChatRouting':
+          if (data.routing) {
+            await vscode.workspace
+              .getConfiguration('editormate')
+              .update('chatRouting', data.routing, vscode.ConfigurationTarget.Global);
+            vscode.window.setStatusBarMessage(`📱 EditorMate: Routing set to ${data.routing}`, 2500);
+            this.refresh();
+          }
+          break;
+        case 'remoteCommand':
+          if (data.cmd) {
+            await this.handleRemoteCommand(data.cmd);
+          }
+          break;
+        case 'resolveExecution':
+          await this.guard.resolvePendingExecution(data.action || 'allow');
+          this.refresh();
+          break;
+        case 'setGuardMode':
+          if (data.mode) {
+            await this.guard.setApprovalMode(data.mode as ApprovalMode);
+            this.refresh();
+          }
+          break;
+        case 'clearWhitelist':
+          await this.guard.clearWhitelist();
+          this.refresh();
+          break;
+        case 'captureScreen':
+          await this.remoteActions.triggerCaptureScreen();
+          break;
+        case 'remoteTerminal':
+          await this.remoteActions.triggerRemoteTerminal();
+          break;
+        case 'renameDevice':
+          await this.remoteActions.triggerRenameDevice();
+          break;
+        case 'enableCompanionService':
+        case 'startDaemon':
+          await vscode.commands.executeCommand('editormate.enableCompanionService');
+          break;
+        case 'changeIcon':
+          await this.remoteActions.triggerChangeIcon(this._statusBarItem);
+          break;
+        case 'setMainTab':
+          if (data.tab === 'settings' || data.tab === 'dashboard') {
+            this._activeMainTab = data.tab;
+          }
+          break;
+        case 'enterLicense':
+          this._activeMainTab = 'settings';
+          await this.remoteActions.triggerEnterLicense(data.licenseKey);
+          this.refresh();
+          break;
+        case 'deactivateLicense':
+          this._activeMainTab = 'settings';
+          await this.remoteActions.triggerDeactivateLicense();
+          this.refresh();
+          break;
+        case 'updatePreferences':
+          this._activeMainTab = 'settings';
+          if (data.preferences) {
+            const existing = this._context.globalState.get<any>('editormate.preferences') || {
+              sttWhisperEnabled: true,
+              sttLlmFiltering: true,
+              videoToTextEnabled: true,
+              rawAttachmentsEnabled: true,
+              screenshotScope: 'screen',
+            };
+            const updated = { ...existing, ...data.preferences };
+            await this._context.globalState.update('editormate.preferences', updated);
+            try {
+              const payload = JSON.stringify({ preferences: updated });
+              const pReq = http.request('http://127.0.0.1:4588/api/preferences', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) }
+              });
+              pReq.on('error', () => {});
+              pReq.write(payload);
+              pReq.end();
+            } catch {}
+            vscode.window.setStatusBarMessage('⚙️ EditorMate: Preferences updated', 2500);
+            this.refresh();
+          }
+          break;
+        case 'viewLogs':
+          await this.remoteActions.triggerViewLogs();
+          break;
+        case 'refresh':
+          this.refresh();
+          break;
+      }
+    });
+  }
+
+  private async handleRemoteCommand(cmd: string): Promise<void> {
+    if (cmd === '/snap') {
+      await this.remoteActions.triggerCaptureScreen();
+    } else if (cmd === '/pdf') {
+      vscode.env.openExternal(vscode.Uri.parse('http://127.0.0.1:4588/api/report/pdf'));
+    } else if (cmd === '/chats' || cmd === '/status') {
+      vscode.commands.executeCommand('editormate.status');
+    } else if (cmd === '/terminal') {
+      await this.remoteActions.triggerRemoteTerminal();
+    } else if (cmd === '/approve') {
+      const resolved = await this.guard.resolvePendingExecution('allow');
+      try { await vscode.commands.executeCommand('workbench.action.modalConfirmation.confirm'); } catch {}
+      try { await vscode.commands.executeCommand('notifications.acceptPrimaryAction'); } catch {}
+      vscode.window.setStatusBarMessage(resolved ? '⚡ EditorMate: Approved pending command' : '⚡ EditorMate: Execution pre-approved', 3000);
+    } else if (cmd === '/reject') {
+      const resolved = await this.guard.resolvePendingExecution('deny');
+      try { await vscode.commands.executeCommand('workbench.action.modalConfirmation.cancel'); } catch {}
+      try { await vscode.commands.executeCommand('notifications.hideToasts'); } catch {}
+      vscode.window.setStatusBarMessage(resolved ? '🚫 EditorMate: Denied pending command' : '🚫 EditorMate: Command cancelled', 3000);
+    } else if (cmd === '/diff') {
+      try { await vscode.commands.executeCommand('workbench.view.scm'); } catch {}
+      vscode.window.setStatusBarMessage('📊 EditorMate: Opened Source Control Diff', 2500);
+    } else if (cmd === '/stop') {
+      try { await vscode.commands.executeCommand('workbench.action.debug.stop'); } catch {}
+      vscode.window.setStatusBarMessage('🛑 EditorMate: Stop signal dispatched', 2500);
+    } else if (cmd === '/select') {
+      await this.remoteActions.triggerSetActiveSession(this.getMySessionId());
+    } else {
+      vscode.window.showInformationMessage(`⚡ EditorMate: Executed remote command ${cmd}`);
+    }
+  }
+
+  public async refresh() {
+    const html = await this.getHtml();
+    for (const view of this._views) {
+      view.webview.html = html;
+    }
+  }
+
+  private async getHtml(): Promise<string> {
+    const workspaceName = vscode.workspace.workspaceFolders?.[0]?.name || 'Current Workspace';
+    const savedIcon = this._context.globalState.get<string>('editormate.icon') || 'remote';
+    const iconEmoji =
+      savedIcon === 'shield' ? '🛡️' :
+      savedIcon === 'device-mobile' ? '📱' :
+      savedIcon === 'robot' ? '🤖' :
+      savedIcon === 'zap' ? '⚡' :
+      savedIcon === 'radio-tower' ? '📡' :
+      savedIcon === 'terminal' ? '💻' :
+      savedIcon === 'sparkle' ? '✨' : '🎮';
+
+    const mySessionId = this.getMySessionId();
+    const daemon = this._cachedDaemonStatus || {};
+    const activeSessionId = daemon.activeSessionId || mySessionId;
+    const realIde = getRealIdeName();
+    const connectedSessions = (daemon.sessions && daemon.sessions.length > 0)
+      ? daemon.sessions.filter((s: any) => isHostIdeRunning(s.ide || s.ideType))
+      : [{ id: mySessionId, name: workspaceName, ide: realIde }];
+    // Ensure the current IDE window is always present in connectedSessions
+    if (!connectedSessions.some((s: any) => s.id === mySessionId)) {
+      connectedSessions.unshift({ id: mySessionId, name: workspaceName, ide: realIde });
+    }
+    const isActiveChatTarget = !activeSessionId || activeSessionId === mySessionId;
+    const selectedCompanion = this._context.globalState.get<string>('editormate.selectedCompanion') || '';
+
+    const linkedAccounts = (daemon.linkedAccounts || []).filter((a: any) =>
+      (a.platform === 'whatsapp' || a.platform === 'telegram' || a.platform === 'discord' || a.platform === 'slack') &&
+      isRealPairedAccount(a)
+    );
+    const validAccount = linkedAccounts[0];
+    const isDevicePaired = Boolean(validAccount);
+    const deviceName = isDevicePaired
+      ? (validAccount.userHandle ? `${validAccount.userHandle} (${validAccount.platform.toUpperCase()})` : `Paired (${validAccount.platform.toUpperCase()})`)
+      : 'No companion paired';
+    const deviceSeat = this._context.globalState.get<string>('editormate.deviceSeat') || 'd3e577aed5e099f7';
+    const currentRouting = vscode.workspace.getConfiguration('editormate').get<string>('chatRouting') || 'autoPin';
+
+    const builtinCommands = this.commandsManager.getBuiltinCommands();
+    const customSlots = this.commandsManager.getCustomSlots();
+    const aliases = this.commandsManager.getAliases();
+    const approvalMode = this.guard.getApprovalMode();
+    const whitelistCount = this.guard.getWhitelist().length;
+
+    const lic = daemon.license || {};
+    const isActivated = Boolean(lic.isActivated);
+    const trialDaysLeft = typeof lic.trialDaysLeft === 'number' ? lic.trialDaysLeft : 6;
+    const trialMaxDays = typeof lic.trialMaxDays === 'number' ? lic.trialMaxDays : 7;
+    const daysRemainingText = lic.daysRemainingText || `${trialDaysLeft} days remaining of 7-day trial`;
+    const licenseKeyMasked = lic.licenseKey;
+    const targetUserWaNumber = daemon.targetUserWaNumber || this._context.globalState.get<string>('editormate.targetUserWaNumber') || '';
+
+    const channelData: Record<string, any> = {
+      telegram: {
+        title: 'Telegram Bot',
+        subtitle: 'Scan QR to open @EditorMate_bot',
+        badge: 'LIVE',
+        badgeClass: 'badge-live',
+        qrUrl: 'http://127.0.0.1:4588/api/pair/qr?platform=telegram&t=' + Date.now(),
+        link: 'https://t.me/EditorMate_bot?start=pair',
+      },
+      discord: {
+        title: 'Discord Personal App',
+        subtitle: 'Click to add EditorMate to Your Account (User App)',
+        badge: 'READY',
+        badgeClass: 'badge-purple',
+        qrUrl: 'http://127.0.0.1:4588/api/pair/qr?platform=discord&t=' + Date.now(),
+        link: 'https://discord.com/oauth2/authorize?client_id=1559887036666744912&integration_type=1&scope=applications.commands',
+      },
+      whatsapp: {
+        title: 'WhatsApp Multi-Device',
+        subtitle: 'Scan with WhatsApp ➔ Linked Devices',
+        badge: 'LIVE',
+        badgeClass: 'badge-live',
+        qrUrl: 'http://127.0.0.1:4588/api/pair/qr?platform=whatsapp&t=' + Date.now(),
+        link: 'http://127.0.0.1:4588/api/pair/qr?platform=whatsapp',
+      },
+      slack: {
+        title: 'Slack Socket Mode App',
+        subtitle: 'Configure or open your Slack App at api.slack.com/apps',
+        badge: 'SOCKET',
+        badgeClass: 'badge-live',
+        qrUrl: 'http://127.0.0.1:4588/api/pair/qr?platform=slack&t=' + Date.now(),
+        link: 'https://api.slack.com/apps',
+      },
+    };
+
+    const preferences = this._context.globalState.get<any>('editormate.preferences') || {
+      sttWhisperEnabled: true,
+      sttLlmFiltering: true,
+      videoToTextEnabled: true,
+      rawAttachmentsEnabled: true,
+      screenshotScope: 'screen',
+    };
+
+    const isDaemonOnline = Boolean(daemon && (daemon.status === 'OK' || daemon.port === 4588));
+
+    return generateWebviewHtml(
+      {
+        iconEmoji,
+        workspaceName,
+        deviceName,
+        isDevicePaired,
+        isDaemonOnline,
+        deviceSeat,
+        currentRouting,
+        licenseTier: isActivated ? 'PRO' : 'TRIAL',
+        isActivated,
+        trialDaysLeft,
+        trialMaxDays,
+        daysRemainingText,
+        licenseKeyMasked,
+        mySessionId,
+        activeSessionId,
+        isActiveChatTarget,
+        connectedSessions,
+        linkedAccounts,
+        recentChatMessages: this._cachedInbox,
+        targetUserWaNumber,
+        approvalMode,
+        builtinCommands,
+        customSlots,
+        aliases,
+        whitelistCount,
+        preferences,
+        activeMainTab: this._activeMainTab,
+        selectedCompanion,
+        realIde,
+        pendingExecutions: this.guard.getPendingExecutions(),
+      },
+      channelData
+    );
+  }
+}
+