editormate 1.0.2 → 1.0.5

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

@@ -1,26 +0,0 @@
-{
-    "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

@@ -1,25 +0,0 @@
-{
-  "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

@@ -1,154 +0,0 @@
-{
-  "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

@@ -1,88 +0,0 @@
-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

@@ -1,42 +0,0 @@
-#!/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

@@ -1,201 +0,0 @@
-/**
- * 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}`);
-    }
-  }
-}