@clavon/clav-agent 1.0.0

package/bin/clav-agent.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+const { execSync } = require('child_process');
+const path = require('path');
+
+try {
+  const electronPath = require('electron');
+  const appPath = path.join(__dirname, '..');
+  execSync(`"${electronPath}" "${appPath}"`, { stdio: 'inherit' });
+} catch (error) {
+  console.error('Failed to start Clav Agent:', error.message);
+  process.exit(1);
+}

package/dist/main/index.js

@@ -0,0 +1,521 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const electron = require("electron");
+const path = require("path");
+const utils = require("@electron-toolkit/utils");
+const fs = require("fs");
+const child_process = require("child_process");
+let tray = null;
+let isConnected = false;
+function setupTray(mainWindow) {
+  const iconPath = path.join(__dirname, "../../assets/icons/tray-icon.png");
+  let icon;
+  try {
+    icon = electron.nativeImage.createFromPath(iconPath);
+    if (icon.isEmpty()) {
+      icon = createDefaultIcon();
+    }
+  } catch {
+    icon = createDefaultIcon();
+  }
+  tray = new electron.Tray(icon.resize({ width: 16, height: 16 }));
+  tray.setToolTip("Clav Agent — Disconnected");
+  const updateMenu = () => {
+    const contextMenu = electron.Menu.buildFromTemplate([
+      {
+        label: `Clav Agent ${isConnected ? "(Connected)" : "(Disconnected)"}`,
+        enabled: false
+      },
+      { type: "separator" },
+      {
+        label: "Open",
+        click: () => {
+          mainWindow.show();
+          mainWindow.focus();
+        }
+      },
+      {
+        label: "Settings",
+        click: () => {
+          mainWindow.show();
+          mainWindow.focus();
+          mainWindow.webContents.send("navigate", "/settings");
+        }
+      },
+      { type: "separator" },
+      {
+        label: "Quit",
+        click: () => {
+          electron.app.isQuitting = true;
+          electron.app.quit();
+        }
+      }
+    ]);
+    tray?.setContextMenu(contextMenu);
+  };
+  updateMenu();
+  tray.on("double-click", () => {
+    mainWindow.show();
+    mainWindow.focus();
+  });
+  global.__updateTrayConnection = (connected) => {
+    isConnected = connected;
+    tray?.setToolTip(`Clav Agent — ${connected ? "Connected" : "Disconnected"}`);
+    updateMenu();
+  };
+}
+function createDefaultIcon() {
+  return electron.nativeImage.createFromDataURL(
+    "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAARElEQVQ4T2NkYPj/n4EBCBgZGf8zMDL+Z2Bk+M/IwPCfkZHxPwMj438GRsb/jIyM/xkZGf8zMjL+Z2AAqmFkZPwPAFUOEBH0sOZ3AAAAAElFTkSuQmCC"
+  );
+}
+const BLOCKED_PATTERNS$1 = [
+  /[/\\]\.ssh[/\\]/i,
+  /[/\\]\.aws[/\\]/i,
+  /[/\\]\.gnupg[/\\]/i,
+  /[/\\]\.env$/i,
+  /[/\\]\.env\./i,
+  /[/\\]credentials/i,
+  /^[A-Z]:[/\\]Windows[/\\]/i,
+  /^[A-Z]:[/\\]Program Files/i,
+  /^\/etc\//i,
+  /^\/usr\//i,
+  /^\/bin\//i,
+  /^\/sbin\//i
+];
+function isPathBlocked(filePath) {
+  const normalized = path.resolve(filePath);
+  return BLOCKED_PATTERNS$1.some((p) => p.test(normalized));
+}
+async function executeFileTool(toolName, params) {
+  const filePath = params.path;
+  if (!filePath) {
+    return { success: false, error: "Missing required parameter: path" };
+  }
+  if (isPathBlocked(filePath)) {
+    return { success: false, error: `Access denied: "${filePath}" is in a restricted location.` };
+  }
+  switch (toolName) {
+    case "desktop_file_read":
+      return fileRead(filePath, params.encoding);
+    case "desktop_file_write":
+      return fileWrite(filePath, params.content);
+    case "desktop_file_list":
+      return fileList(filePath);
+    case "desktop_file_delete":
+      return fileDelete(filePath);
+    case "desktop_file_search":
+      return fileSearch(filePath, params.pattern);
+    default:
+      return { success: false, error: `Unknown file tool: ${toolName}` };
+  }
+}
+async function fileRead(filePath, encoding) {
+  try {
+    const content = await fs.promises.readFile(path.resolve(filePath), {
+      encoding: encoding || "utf-8"
+    });
+    const stats = await fs.promises.stat(path.resolve(filePath));
+    return {
+      success: true,
+      data: {
+        content,
+        size: stats.size,
+        modified: stats.mtime.toISOString()
+      }
+    };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { success: false, error: `File not found: ${filePath}` };
+    }
+    return { success: false, error: error.message };
+  }
+}
+async function fileWrite(filePath, content) {
+  if (content === void 0 || content === null) {
+    return { success: false, error: "Missing required parameter: content" };
+  }
+  try {
+    const resolved = path.resolve(filePath);
+    await fs.promises.mkdir(path.join(resolved, ".."), { recursive: true });
+    await fs.promises.writeFile(resolved, content, "utf-8");
+    const stats = await fs.promises.stat(resolved);
+    return {
+      success: true,
+      data: {
+        path: resolved,
+        size: stats.size,
+        message: `File written successfully (${stats.size} bytes)`
+      }
+    };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+async function fileList(dirPath) {
+  try {
+    const resolved = path.resolve(dirPath);
+    const entries = await fs.promises.readdir(resolved, { withFileTypes: true });
+    const items = await Promise.all(
+      entries.slice(0, 200).map(async (entry) => {
+        const fullPath = path.join(resolved, entry.name);
+        try {
+          const stats = await fs.promises.stat(fullPath);
+          return {
+            name: entry.name,
+            type: entry.isDirectory() ? "directory" : "file",
+            size: stats.size,
+            modified: stats.mtime.toISOString()
+          };
+        } catch {
+          return {
+            name: entry.name,
+            type: entry.isDirectory() ? "directory" : "file"
+          };
+        }
+      })
+    );
+    return {
+      success: true,
+      data: {
+        path: resolved,
+        count: entries.length,
+        items,
+        truncated: entries.length > 200
+      }
+    };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { success: false, error: `Directory not found: ${dirPath}` };
+    }
+    return { success: false, error: error.message };
+  }
+}
+async function fileDelete(filePath) {
+  try {
+    const resolved = path.resolve(filePath);
+    const stats = await fs.promises.stat(resolved);
+    if (stats.isDirectory()) {
+      return { success: false, error: "Cannot delete directories. Use shell commands for that." };
+    }
+    await fs.promises.unlink(resolved);
+    return {
+      success: true,
+      data: {
+        path: resolved,
+        message: `Deleted: ${path.basename(resolved)}`
+      }
+    };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { success: false, error: `File not found: ${filePath}` };
+    }
+    return { success: false, error: error.message };
+  }
+}
+async function fileSearch(dirPath, pattern) {
+  if (!pattern) {
+    return { success: false, error: "Missing required parameter: pattern" };
+  }
+  try {
+    const resolved = path.resolve(dirPath);
+    const regex = new RegExp(pattern, "i");
+    const matches = [];
+    async function walk(dir, depth) {
+      if (depth > 5 || matches.length >= 50) return;
+      const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+        const fullPath = path.join(dir, entry.name);
+        if (regex.test(entry.name)) {
+          matches.push(fullPath);
+        }
+        if (entry.isDirectory()) {
+          await walk(fullPath, depth + 1);
+        }
+      }
+    }
+    await walk(resolved, 0);
+    return {
+      success: true,
+      data: {
+        pattern,
+        searchDir: resolved,
+        matches,
+        count: matches.length,
+        truncated: matches.length >= 50
+      }
+    };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+const SAFE_COMMANDS = [
+  "ls",
+  "dir",
+  "pwd",
+  "cd",
+  "git status",
+  "git log",
+  "git branch",
+  "git diff",
+  "git remote -v",
+  "node --version",
+  "npm --version",
+  "python --version",
+  "pip --version",
+  "whoami",
+  "hostname",
+  "date",
+  "echo",
+  "type",
+  "cat"
+];
+const BLOCKED_PATTERNS = [
+  /rm\s+-rf\s+[/\\]/i,
+  /del\s+\/s\s+\/q/i,
+  /format\s+[A-Z]:/i,
+  /mkfs/i,
+  /dd\s+if=/i,
+  />\s*\/dev\/sd/i,
+  /shutdown/i,
+  /reboot/i,
+  /reg\s+delete/i,
+  /net\s+user.*\/delete/i
+];
+function isSafeCommand(command) {
+  const trimmed = command.trim().toLowerCase();
+  return SAFE_COMMANDS.some((safe) => trimmed.startsWith(safe));
+}
+function isBlockedCommand(command) {
+  return BLOCKED_PATTERNS.some((p) => p.test(command));
+}
+const MAX_OUTPUT = 5e4;
+const TIMEOUT_MS = 3e4;
+async function executeShellTool(toolName, params) {
+  const command = params.command;
+  const cwd = params.cwd;
+  if (!command) {
+    return { success: false, error: "Missing required parameter: command" };
+  }
+  if (isBlockedCommand(command)) {
+    return {
+      success: false,
+      error: "This command is blocked for safety reasons."
+    };
+  }
+  if (toolName === "desktop_shell_exec_safe" && !isSafeCommand(command)) {
+    return {
+      success: false,
+      error: `Command "${command}" is not in the safe command whitelist. Use desktop_shell_exec instead (requires approval).`
+    };
+  }
+  const workingDir = cwd ? path.resolve(cwd) : void 0;
+  return new Promise((resolveResult) => {
+    child_process.exec(
+      command,
+      {
+        cwd: workingDir,
+        timeout: TIMEOUT_MS,
+        maxBuffer: MAX_OUTPUT,
+        windowsHide: true
+      },
+      (error, stdout, stderr) => {
+        if (error) {
+          if (error.killed) {
+            resolveResult({
+              success: false,
+              error: `Command timed out after ${TIMEOUT_MS / 1e3}s`
+            });
+            return;
+          }
+          resolveResult({
+            success: false,
+            error: stderr || error.message,
+            data: {
+              stdout: stdout?.substring(0, MAX_OUTPUT),
+              stderr: stderr?.substring(0, MAX_OUTPUT),
+              exitCode: error.code
+            }
+          });
+          return;
+        }
+        resolveResult({
+          success: true,
+          data: {
+            stdout: stdout.substring(0, MAX_OUTPUT),
+            stderr: stderr?.substring(0, MAX_OUTPUT) || "",
+            exitCode: 0
+          }
+        });
+      }
+    );
+  });
+}
+async function executeClipboardTool(toolName, params) {
+  switch (toolName) {
+    case "desktop_clipboard_read": {
+      const text = electron.clipboard.readText();
+      return {
+        success: true,
+        data: {
+          content: text,
+          length: text.length
+        }
+      };
+    }
+    case "desktop_clipboard_write": {
+      const text = params.text;
+      if (!text && text !== "") {
+        return { success: false, error: "Missing required parameter: text" };
+      }
+      electron.clipboard.writeText(text);
+      return {
+        success: true,
+        data: {
+          message: `Copied ${text.length} characters to clipboard`,
+          length: text.length
+        }
+      };
+    }
+    default:
+      return { success: false, error: `Unknown clipboard tool: ${toolName}` };
+  }
+}
+async function executeLocalTool(toolName, params) {
+  const startTime = Date.now();
+  try {
+    let result;
+    switch (toolName) {
+      case "desktop_file_read":
+      case "desktop_file_write":
+      case "desktop_file_list":
+      case "desktop_file_delete":
+      case "desktop_file_search":
+        result = await executeFileTool(toolName, params);
+        break;
+      case "desktop_shell_exec":
+      case "desktop_shell_exec_safe":
+        result = await executeShellTool(toolName, params);
+        break;
+      case "desktop_clipboard_read":
+      case "desktop_clipboard_write":
+        result = await executeClipboardTool(toolName, params);
+        break;
+      default:
+        result = { success: false, error: `Unknown tool: ${toolName}` };
+    }
+    result.executionTimeMs = Date.now() - startTime;
+    return result;
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+      executionTimeMs: Date.now() - startTime
+    };
+  }
+}
+function registerIpcHandlers() {
+  electron.ipcMain.on("window:minimize", (event) => {
+    electron.BrowserWindow.fromWebContents(event.sender)?.minimize();
+  });
+  electron.ipcMain.on("window:maximize", (event) => {
+    const win = electron.BrowserWindow.fromWebContents(event.sender);
+    if (win?.isMaximized()) {
+      win.unmaximize();
+    } else {
+      win?.maximize();
+    }
+  });
+  electron.ipcMain.on("window:close", (event) => {
+    electron.BrowserWindow.fromWebContents(event.sender)?.hide();
+  });
+  electron.ipcMain.handle("window:isMaximized", (event) => {
+    return electron.BrowserWindow.fromWebContents(event.sender)?.isMaximized() ?? false;
+  });
+  electron.ipcMain.handle("tools:execute", async (_event, toolName, params) => {
+    return executeLocalTool(toolName, params);
+  });
+  electron.ipcMain.handle("clipboard:read", () => {
+    return electron.clipboard.readText();
+  });
+  electron.ipcMain.handle("clipboard:write", (_event, text) => {
+    electron.clipboard.writeText(text);
+    return { success: true };
+  });
+  electron.ipcMain.handle("app:version", () => {
+    const { app } = require("electron");
+    return app.getVersion();
+  });
+  electron.ipcMain.on("tray:setConnected", (_event, connected) => {
+    const updater = global.__updateTrayConnection;
+    if (updater) updater(connected);
+  });
+}
+exports.mainWindow = null;
+const gotTheLock = electron.app.requestSingleInstanceLock();
+if (!gotTheLock) {
+  electron.app.quit();
+} else {
+  electron.app.on("second-instance", () => {
+    if (exports.mainWindow) {
+      if (exports.mainWindow.isMinimized()) exports.mainWindow.restore();
+      exports.mainWindow.focus();
+    }
+  });
+}
+function createWindow() {
+  exports.mainWindow = new electron.BrowserWindow({
+    width: 420,
+    height: 700,
+    minWidth: 360,
+    minHeight: 500,
+    frame: false,
+    titleBarStyle: "hidden",
+    backgroundColor: "#0a0a1a",
+    icon: path.join(__dirname, "../../assets/icons/icon.ico"),
+    webPreferences: {
+      preload: path.join(__dirname, "../preload/index.js"),
+      contextIsolation: true,
+      nodeIntegration: false,
+      sandbox: true
+    },
+    show: false
+  });
+  exports.mainWindow.on("ready-to-show", () => {
+    exports.mainWindow?.show();
+  });
+  exports.mainWindow.webContents.setWindowOpenHandler(({ url }) => {
+    electron.shell.openExternal(url);
+    return { action: "deny" };
+  });
+  if (utils.is.dev && process.env["ELECTRON_RENDERER_URL"]) {
+    exports.mainWindow.loadURL(process.env["ELECTRON_RENDERER_URL"]);
+  } else {
+    exports.mainWindow.loadFile(path.join(__dirname, "../renderer/index.html"));
+  }
+  exports.mainWindow.on("close", (event) => {
+    if (!electron.app.isQuitting) {
+      event.preventDefault();
+      exports.mainWindow?.hide();
+    }
+  });
+}
+electron.app.whenReady().then(() => {
+  utils.electronApp.setAppUserModelId("com.clavon.desktop");
+  electron.app.on("browser-window-created", (_, window) => {
+    utils.optimizer.watchWindowShortcuts(window);
+  });
+  registerIpcHandlers();
+  createWindow();
+  setupTray(exports.mainWindow);
+});
+electron.app.on("window-all-closed", () => {
+});
+electron.app.on("activate", () => {
+  if (electron.BrowserWindow.getAllWindows().length === 0) {
+    createWindow();
+  } else {
+    exports.mainWindow?.show();
+  }
+});

package/dist/preload/index.js

@@ -0,0 +1,26 @@
+"use strict";
+const electron = require("electron");
+electron.contextBridge.exposeInMainWorld("clavAPI", {
+  // Window controls
+  minimize: () => electron.ipcRenderer.send("window:minimize"),
+  maximize: () => electron.ipcRenderer.send("window:maximize"),
+  close: () => electron.ipcRenderer.send("window:close"),
+  isMaximized: () => electron.ipcRenderer.invoke("window:isMaximized"),
+  // Local tool execution
+  executeTool: (toolName, params) => electron.ipcRenderer.invoke("tools:execute", toolName, params),
+  // Clipboard
+  readClipboard: () => electron.ipcRenderer.invoke("clipboard:read"),
+  writeClipboard: (text) => electron.ipcRenderer.invoke("clipboard:write", text),
+  // App info
+  getVersion: () => electron.ipcRenderer.invoke("app:version"),
+  // Tray state
+  setTrayConnected: (connected) => electron.ipcRenderer.send("tray:setConnected", connected),
+  // Navigation listener (from tray menu)
+  onNavigate: (callback) => {
+    const handler = (_event, path) => callback(path);
+    electron.ipcRenderer.on("navigate", handler);
+    return () => electron.ipcRenderer.removeListener("navigate", handler);
+  },
+  // Platform info
+  platform: process.platform
+});