editormate 0.0.0-stage → 1.0.2

package/extension/node_modules/@types/vscode/package.json

@@ -0,0 +1,26 @@
+{
+    "name": "@types/vscode",
+    "version": "1.140.0",
+    "description": "TypeScript definitions for vscode",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/vscode",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Visual Studio Code Team, Microsoft",
+            "githubUsername": "microsoft",
+            "url": "https://github.com/microsoft"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/vscode"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "peerDependencies": {},
+    "typesPublisherContentHash": "427dc5ba4504c5fd5e109ddcb5dddf9fbb3123fbc69ed3b5e767842a869a1e1a",
+    "typeScriptVersion": "5.6"
+}

package/extension/package-lock.json

@@ -0,0 +1,25 @@
+{
+  "name": "editormate",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "editormate",
+      "version": "1.0.0",
+      "devDependencies": {
+        "@types/vscode": "^1.140.0"
+      },
+      "engines": {
+        "vscode": "^1.80.0"
+      }
+    },
+    "node_modules/@types/vscode": {
+      "version": "1.140.0",
+      "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.140.0.tgz",
+      "integrity": "sha512-KAB5RBZIgnUhpp4mKsVJPPHLOQKu6WtGy2xpfWjaajEXO4xIIC+UESAXLiQ9ewx6QD1uBmvC/S8BJzkbvv4bRA==",
+      "dev": true,
+      "license": "MIT"
+    }
+  }
+}

package/extension/package.json

@@ -0,0 +1,154 @@
+{
+  "name": "editormate",
+  "displayName": "EditorMate",
+  "description": "Mobile companion and status monitor for AI coding workflows.",
+  "version": "1.0.2",
+  "publisher": "praveenojha",
+  "author": {
+    "name": "Praveen Ojha",
+    "url": "https://praveenojha.com"
+  },
+  "homepage": "https://praveenojha.com/store/editormate",
+  "bugs": {
+    "url": "https://praveenojha.com/store/editormate#support"
+  },
+  "license": "Commercial",
+  "icon": "assets/icon.png",
+  "engines": {
+    "vscode": "^1.80.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/PraveenOjha/editormate"
+  },
+  "categories": [
+    "Programming Languages",
+    "Machine Learning",
+    "Other"
+  ],
+  "keywords": [
+    "companion",
+    "productivity",
+    "status",
+    "workflow",
+    "editormate"
+  ],
+  "main": "./dist/extension.js",
+  "activationEvents": [
+    "onView:editormate.controlPanel",
+    "onView:editormate.explorerPanel"
+  ],
+  "contributes": {
+    "viewsContainers": {
+      "activitybar": [
+        {
+          "id": "editormate-sidebar",
+          "title": "EditorMate",
+          "icon": "assets/icon.svg"
+        }
+      ]
+    },
+    "views": {
+      "editormate-sidebar": [
+        {
+          "type": "webview",
+          "id": "editormate.controlPanel",
+          "name": "EditorMate"
+        }
+      ],
+      "explorer": [
+        {
+          "type": "webview",
+          "id": "editormate.explorerPanel",
+          "name": "EditorMate"
+        }
+      ]
+    },
+    "commands": [
+      {
+        "command": "editormate.status",
+        "title": "EditorMate: Dashboard"
+      },
+      {
+        "command": "editormate.openSidebar",
+        "title": "EditorMate: Open Sidebar"
+      },
+      {
+        "command": "editormate.connectTelegram",
+        "title": "EditorMate: Connect Telegram"
+      },
+      {
+        "command": "editormate.connectDiscord",
+        "title": "EditorMate: Connect Discord"
+      },
+      {
+        "command": "editormate.connectWhatsApp",
+        "title": "EditorMate: Connect WhatsApp"
+      },
+      {
+        "command": "editormate.testPrompt",
+        "title": "EditorMate: Send Test Card"
+      },
+      {
+        "command": "editormate.pinToChat",
+        "title": "EditorMate: Pin Response"
+      },
+      {
+        "command": "editormate.manageAliases",
+        "title": "EditorMate: Manage Aliases"
+      },
+      {
+        "command": "editormate.addAlias",
+        "title": "EditorMate: Add Alias"
+      },
+      {
+        "command": "editormate.enableCompanionService",
+        "title": "EditorMate: Enable Companion Service"
+      }
+    ],
+    "configuration": {
+      "title": "EditorMate",
+      "properties": {
+        "editormate.chatRouting": {
+          "type": "string",
+          "enum": [
+            "autoPin",
+            "autoSubmit",
+            "quickChat",
+            "manualToast"
+          ],
+          "enumDescriptions": [
+            "Pin incoming message into active chat prompt",
+            "Submit incoming message to active agent",
+            "Open Quick Chat prompt with message",
+            "Show notification toast with action button"
+          ],
+          "default": "autoPin",
+          "description": "Select routing mode for incoming messages"
+        },
+        "editormate.daemonPort": {
+          "type": "number",
+          "default": 4588,
+          "description": "Port of the companion daemon"
+        },
+        "editormate.botUsername": {
+          "type": "string",
+          "default": "EditorMate_bot",
+          "description": "Telegram bot username"
+        },
+        "editormate.showStatusBar": {
+          "type": "boolean",
+          "default": true,
+          "description": "Show status in the status bar"
+        }
+      }
+    }
+  },
+  "scripts": {
+    "prepackage": "mkdir -p daemon bin scripts && cp -r ../dist/* daemon/ && cp -r ../bin/* bin/ && cp -r ../scripts/* scripts/ 2>/dev/null || true",
+    "package": "npm run prepackage && npx @vscode/vsce package --no-dependencies --allow-missing-repository --allow-star-activation"
+  },
+  "devDependencies": {
+    "@types/vscode": "^1.80.0"
+  }
+}

package/extension/scripts/build_protected.js

@@ -0,0 +1,88 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import JavaScriptObfuscator from 'javascript-obfuscator';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = path.resolve(__dirname, '..');
+
+const obfuscationOptions = {
+  compact: true,
+  controlFlowFlattening: true,
+  controlFlowFlatteningThreshold: 0.75,
+  deadCodeInjection: true,
+  deadCodeInjectionThreshold: 0.3,
+  debugProtection: false,
+  disableConsoleOutput: false,
+  identifierNamesGenerator: 'hexadecimal',
+  log: false,
+  numbersToExpressions: true,
+  renameGlobals: false,
+  selfDefending: false,
+  simplify: true,
+  splitStrings: true,
+  splitStringsChunkLength: 8,
+  stringArray: true,
+  stringArrayCallsTransform: true,
+  stringArrayEncoding: ['base64'],
+  stringArrayIndexShift: true,
+  stringArrayRotate: true,
+  stringArrayShuffle: true,
+  stringArrayWrappersCount: 2,
+  stringArrayWrappersChainedCalls: true,
+  stringArrayWrappersParametersMaxCount: 4,
+  stringArrayWrappersType: 'function',
+  stringArrayThreshold: 0.8,
+  target: 'node',
+  unicodeEscapeSequence: false
+};
+
+const legalBanner = `/**
+ * EditorMate — Universal AI Remote Control & Companion
+ * Copyright (c) 2026 Praveen Ojha (https://praveenojha.com). All Rights Reserved.
+ * PROPRIETARY AND CONFIDENTIAL.
+ * Designed & written by Praveen Ojha.
+ * Even if you can inspect or read this compiled code, you may NOT copy, modify,
+ * distribute, or reverse-engineer any part of this software without prior written consent.
+ */
+`;
+
+function obfuscateDirectory(dirPath) {
+  if (!fs.existsSync(dirPath)) return;
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name !== 'node_modules' && entry.name !== '.git' && entry.name !== 'webview') {
+        obfuscateDirectory(fullPath);
+      }
+    } else if (entry.isFile() && entry.name.endsWith('.js') && !entry.name.endsWith('.d.ts')) {
+      try {
+        const sourceCode = fs.readFileSync(fullPath, 'utf8');
+        const obfuscationResult = JavaScriptObfuscator.obfuscate(sourceCode, obfuscationOptions);
+        const finalCode = legalBanner + obfuscationResult.getObfuscatedCode();
+        fs.writeFileSync(fullPath, finalCode, 'utf8');
+        console.log(`🛡️  Obfuscated: ${path.relative(rootDir, fullPath)}`);
+      } catch (err) {
+        console.error(`❌ Failed to obfuscate ${fullPath}:`, err.message);
+      }
+    }
+  }
+}
+
+console.log('🚀 Starting EditorMate Proprietary Code Obfuscation...');
+const targetDirs = [
+  path.join(rootDir, 'dist'),
+  path.join(rootDir, 'extension', 'dist')
+];
+
+for (const dir of targetDirs) {
+  if (fs.existsSync(dir)) {
+    console.log(`\n📦 Protecting folder: ${path.relative(rootDir, dir)}`);
+    obfuscateDirectory(dir);
+  }
+}
+
+console.log('\n✅ All proprietary code successfully obfuscated and secured for distribution!');

package/extension/scripts/transcribe_audio.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+"""
+EditorMate Whisper Speech-to-Text Transcriber
+Fast sub-second local CPU/GPU speech transcription for incoming voice notes.
+"""
+
+import sys
+import os
+import json
+
+def transcribe(audio_path: str):
+    if not os.path.exists(audio_path):
+        print(json.dumps({"error": f"Audio file not found: {audio_path}", "text": ""}))
+        sys.exit(1)
+
+    try:
+        from faster_whisper import WhisperModel
+        # Use tiny model for sub-second CPU inference (~39 MB, int8 quantized)
+        model = WhisperModel("tiny", device="cpu", compute_type="int8")
+        segments, info = model.transcribe(audio_path, beam_size=3, language=None)
+        
+        text_parts = []
+        for segment in segments:
+            text_parts.append(segment.text.strip())
+            
+        full_text = " ".join(text_parts).strip()
+        result = {
+            "success": True,
+            "text": full_text,
+            "language": info.language if hasattr(info, "language") else "en",
+            "duration": round(info.duration, 2) if hasattr(info, "duration") else 0
+        }
+        print(json.dumps(result))
+    except Exception as e:
+        print(json.dumps({"success": False, "error": str(e), "text": ""}))
+        sys.exit(1)
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print(json.dumps({"error": "Usage: transcribe_audio.py <audio_path>", "text": ""}))
+        sys.exit(1)
+    transcribe(sys.argv[1])

package/extension/src/command_guard.ts

@@ -0,0 +1,201 @@
+/**
+ * EditorMate — Remote Execution Security Guard
+ * Enforces execution policies: Allow, Deny, and Allow All (Whitelist).
+ */
+
+import * as vscode from 'vscode';
+
+export type ApprovalMode = 'prompt' | 'allow_all' | 'deny_all';
+
+export interface CommandExecutionRecord {
+  timestamp: number;
+  command: string;
+  alias?: string;
+  source: string;
+  status: 'allowed' | 'denied' | 'auto_allowed';
+}
+
+export class CommandGuard {
+  private _mode: ApprovalMode = 'prompt';
+  private _whitelist = new Set<string>();
+  private _history: CommandExecutionRecord[] = [];
+  private _pendingExecutions: Array<{
+    id: string;
+    command: string;
+    alias?: string;
+    resolve: (action: 'allow' | 'allow_all' | 'deny') => void;
+  }> = [];
+
+  constructor(private readonly _context: vscode.ExtensionContext) {
+    const savedMode = this._context.globalState.get<ApprovalMode>('editormate.approvalMode');
+    if (savedMode) this._mode = savedMode;
+
+    const savedWhitelist = this._context.globalState.get<string[]>('editormate.whitelistedCommands') || [];
+    this._whitelist = new Set(savedWhitelist);
+  }
+
+  public getApprovalMode(): ApprovalMode {
+    return this._mode;
+  }
+
+  public async setApprovalMode(mode: ApprovalMode): Promise<void> {
+    this._mode = mode;
+    await this._context.globalState.update('editormate.approvalMode', mode);
+    vscode.window.setStatusBarMessage(`🛡️ EditorMate Guard Mode: ${mode.toUpperCase().replace('_', ' ')}`, 3000);
+    if (mode === 'allow_all') {
+      while (this._pendingExecutions.length > 0) {
+        const p = this._pendingExecutions.shift();
+        if (p) p.resolve('allow_all');
+      }
+    } else if (mode === 'deny_all') {
+      while (this._pendingExecutions.length > 0) {
+        const p = this._pendingExecutions.shift();
+        if (p) p.resolve('deny');
+      }
+    }
+  }
+
+  public getWhitelist(): string[] {
+    return Array.from(this._whitelist);
+  }
+
+  public async addToWhitelist(command: string): Promise<void> {
+    this._whitelist.add(command);
+    await this._context.globalState.update('editormate.whitelistedCommands', Array.from(this._whitelist));
+  }
+
+  public async clearWhitelist(): Promise<void> {
+    this._whitelist.clear();
+    await this._context.globalState.update('editormate.whitelistedCommands', []);
+  }
+
+  public getHistory(): CommandExecutionRecord[] {
+    return this._history.slice(-20);
+  }
+
+  public getPendingCount(): number {
+    return this._pendingExecutions.length;
+  }
+
+  public getPendingExecutions(): Array<{ id: string; command: string; alias?: string; source?: string }> {
+    return this._pendingExecutions.map((p) => ({
+      id: p.id,
+      command: p.command,
+      alias: p.alias,
+      source: (p as any).source,
+    }));
+  }
+
+  /**
+   * Resolves the earliest pending execution via external signal (/approve, /deny, mobile action, sidebar button)
+   */
+  public async resolvePendingExecution(action: 'allow' | 'allow_all' | 'deny'): Promise<boolean> {
+    if (this._pendingExecutions.length === 0) return false;
+    const pending = this._pendingExecutions.shift();
+    if (pending) {
+      pending.resolve(action);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Evaluates inbound execution request and prompts user if not pre-approved.
+   */
+  public async requestExecution(command: string, alias?: string, source: string = 'Mobile Remote'): Promise<boolean> {
+    const record: CommandExecutionRecord = {
+      timestamp: Date.now(),
+      command,
+      alias,
+      source,
+      status: 'denied',
+    };
+
+    // Policy 1: Global Deny
+    if (this._mode === 'deny_all') {
+      record.status = 'denied';
+      this._history.push(record);
+      vscode.window.showWarningMessage(`🚫 EditorMate: Remote command "${command}" blocked by Deny All policy.`);
+      return false;
+    }
+
+    // Policy 2: Global Allow All or Specific Command Whitelisted
+    if (this._mode === 'allow_all' || this._whitelist.has(command)) {
+      record.status = 'auto_allowed';
+      this._history.push(record);
+      await this.executeSafely(command);
+      vscode.window.setStatusBarMessage(`⚡ EditorMate: Auto-approved command: ${alias ? `[${alias}] ` : ''}${command}`, 3000);
+      return true;
+    }
+
+    // Policy 3: Interactive Prompt (Allow | Deny | Allow All)
+    // Supports both UI buttons AND remote programmatic resolution (/approve, /deny from mobile or chat)
+    const promptLabel = alias ? `Command "${command}" (Alias: "${alias}")` : `Command "${command}"`;
+    const execId = 'exec_' + Date.now() + '_' + Math.random().toString(36).substring(2, 6);
+
+    const promptPromise = new Promise<'allow' | 'allow_all' | 'deny'>((resolve) => {
+      let resolved = false;
+      const safeResolve = (action: 'allow' | 'allow_all' | 'deny') => {
+        if (!resolved) {
+          resolved = true;
+          const idx = this._pendingExecutions.findIndex((p) => p.id === execId);
+          if (idx !== -1) {
+            this._pendingExecutions.splice(idx, 1);
+          }
+          resolve(action);
+        }
+      };
+
+      this._pendingExecutions.push({ id: execId, command, alias, source, resolve: safeResolve } as any);
+
+      vscode.window
+        .showWarningMessage(
+          `⚡ EditorMate Execution Request (${source}):\nDo you want to run ${promptLabel}?`,
+          { modal: false },
+          '✅ Allow',
+          '❌ Deny',
+          '⚡ Allow All'
+        )
+        .then((uiAction) => {
+          if (uiAction === '✅ Allow') safeResolve('allow');
+          else if (uiAction === '⚡ Allow All') safeResolve('allow_all');
+          else if (uiAction === '❌ Deny') safeResolve('deny');
+        });
+
+      // 60-second safety timeout so promises do not leak indefinitely
+      setTimeout(() => {
+        safeResolve('deny');
+      }, 60000);
+    });
+
+    const resolution = await promptPromise;
+
+    if (resolution === 'allow') {
+      record.status = 'allowed';
+      this._history.push(record);
+      await this.executeSafely(command);
+      vscode.window.setStatusBarMessage(`⚡ EditorMate: Allowed remote command: ${command}`, 3000);
+      return true;
+    } else if (resolution === 'allow_all') {
+      await this.addToWhitelist(command);
+      record.status = 'auto_allowed';
+      this._history.push(record);
+      await this.executeSafely(command);
+      vscode.window.showInformationMessage(`🛡️ EditorMate: "${command}" added to whitelist (Pre-Approved).`);
+      return true;
+    } else {
+      record.status = 'denied';
+      this._history.push(record);
+      vscode.window.setStatusBarMessage(`🚫 EditorMate: Denied remote command: ${command}`, 3000);
+      return false;
+    }
+  }
+
+  private async executeSafely(command: string): Promise<void> {
+    try {
+      await vscode.commands.executeCommand(command);
+    } catch (err: any) {
+      vscode.window.showErrorMessage(`EditorMate: Failed executing "${command}": ${err.message}`);
+    }
+  }
+}