wave-code 0.0.2

package/src/utils/clipboard.ts

@@ -0,0 +1,384 @@
+import { unlinkSync, existsSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+export interface ClipboardImageResult {
+  success: boolean;
+  imagePath?: string;
+  error?: string;
+  mimeType?: string;
+}
+
+/**
+ * Read image from clipboard
+ * @returns Promise<ClipboardImageResult> Result containing image path or error information
+ */
+export async function readClipboardImage(): Promise<ClipboardImageResult> {
+  try {
+    const platform = process.platform;
+
+    if (platform === "darwin") {
+      return await readClipboardImageMac();
+    } else if (platform === "win32") {
+      return await readClipboardImageWindows();
+    } else if (platform === "linux") {
+      return await readClipboardImageLinux();
+    } else {
+      return {
+        success: false,
+        error: `Clipboard image reading is not supported on platform: ${platform}`,
+      };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to read clipboard image: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
+/**
+ * Read clipboard image on macOS
+ */
+async function readClipboardImageMac(): Promise<ClipboardImageResult> {
+  const { exec } = await import("child_process");
+  const { promisify } = await import("util");
+  const execAsync = promisify(exec);
+
+  try {
+    // Try to read image data directly to check if image exists
+    const testScript = `
+      tell application "System Events"
+        try
+          set imageData to the clipboard as «class PNGf»
+          return true
+        on error
+          return false
+        end try
+      end tell
+    `;
+
+    let hasImage = false;
+    try {
+      const { stdout: testResult } = await execAsync(
+        `osascript -e '${testScript}'`,
+      );
+      hasImage = testResult.trim() === "true";
+    } catch {
+      hasImage = false;
+    }
+
+    if (!hasImage) {
+      return {
+        success: false,
+        error: "No image found in clipboard",
+      };
+    }
+
+    // Generate temporary file path
+    const tempFilePath = join(tmpdir(), `clipboard-image-${Date.now()}.png`);
+
+    // Use osascript to save clipboard image as file
+    const saveScript = `
+      tell application "System Events"
+        try
+          set imageData to the clipboard as «class PNGf»
+          set fileRef to open for access POSIX file "${tempFilePath}" with write permission
+          write imageData to fileRef
+          close access fileRef
+          return true
+        on error errMsg
+          try
+            close access fileRef
+          end try
+          error errMsg
+        end try
+      end tell
+    `;
+
+    await execAsync(`osascript -e '${saveScript}'`);
+
+    // Verify if file was created successfully
+    if (!existsSync(tempFilePath)) {
+      return {
+        success: false,
+        error: "Failed to save clipboard image to temporary file",
+      };
+    }
+
+    return {
+      success: true,
+      imagePath: tempFilePath,
+      mimeType: "image/png",
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to read clipboard image on macOS: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
+/**
+ * Read clipboard image on Windows
+ */
+async function readClipboardImageWindows(): Promise<ClipboardImageResult> {
+  try {
+    const { exec } = await import("child_process");
+    const { promisify } = await import("util");
+    const execAsync = promisify(exec);
+
+    // Use PowerShell to check if clipboard contains image
+    const checkScript = `
+      Add-Type -AssemblyName System.Windows.Forms
+      if ([System.Windows.Forms.Clipboard]::ContainsImage()) {
+        Write-Output "true"
+      } else {
+        Write-Output "false"
+      }
+    `;
+
+    try {
+      const { stdout } = await execAsync(
+        `powershell -Command "${checkScript}"`,
+      );
+      const hasImage = stdout.trim() === "true";
+
+      if (!hasImage) {
+        return {
+          success: false,
+          error: "No image found in clipboard",
+        };
+      }
+
+      // Generate temporary file path
+      const tempFilePath = join(tmpdir(), `clipboard-image-${Date.now()}.png`);
+
+      // Use PowerShell to save clipboard image
+      const saveScript = `
+        Add-Type -AssemblyName System.Windows.Forms
+        Add-Type -AssemblyName System.Drawing
+        $image = [System.Windows.Forms.Clipboard]::GetImage()
+        if ($image -ne $null) {
+          $image.Save("${tempFilePath.replace(/\\/g, "\\\\")}", [System.Drawing.Imaging.ImageFormat]::Png)
+          Write-Output "true"
+        } else {
+          Write-Output "false"
+        }
+      `;
+
+      const { stdout: saveResult } = await execAsync(
+        `powershell -Command "${saveScript}"`,
+      );
+
+      if (saveResult.trim() !== "true" || !existsSync(tempFilePath)) {
+        return {
+          success: false,
+          error: "Failed to save clipboard image to temporary file",
+        };
+      }
+
+      return {
+        success: true,
+        imagePath: tempFilePath,
+        mimeType: "image/png",
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: `Failed to access clipboard on Windows: ${err instanceof Error ? err.message : String(err)}`,
+      };
+    }
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to read clipboard image on Windows: ${err instanceof Error ? err.message : String(err)}`,
+    };
+  }
+}
+
+/**
+ * Read clipboard image on Linux
+ */
+async function readClipboardImageLinux(): Promise<ClipboardImageResult> {
+  try {
+    // Linux can use tools like xclip or wl-clipboard
+    const { exec } = await import("child_process");
+    const { promisify } = await import("util");
+    const execAsync = promisify(exec);
+
+    // Check if xclip is available
+    try {
+      await execAsync("which xclip");
+    } catch {
+      return {
+        success: false,
+        error:
+          "xclip is required for clipboard image operations on Linux. Please install it: sudo apt-get install xclip",
+      };
+    }
+
+    // Check if clipboard contains image
+    try {
+      await execAsync(
+        "xclip -selection clipboard -t image/png -o > /dev/null 2>&1",
+      );
+    } catch {
+      return {
+        success: false,
+        error: "No image found in clipboard",
+      };
+    }
+
+    // Generate temporary file path
+    const tempFilePath = join(tmpdir(), `clipboard-image-${Date.now()}.png`);
+
+    // Use xclip to save clipboard image
+    try {
+      await execAsync(
+        `xclip -selection clipboard -t image/png -o > "${tempFilePath}"`,
+      );
+
+      if (!existsSync(tempFilePath)) {
+        return {
+          success: false,
+          error: "Failed to save clipboard image to temporary file",
+        };
+      }
+
+      return {
+        success: true,
+        imagePath: tempFilePath,
+        mimeType: "image/png",
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: `Failed to save clipboard image: ${err instanceof Error ? err.message : String(err)}`,
+      };
+    }
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to read clipboard image on Linux: ${err instanceof Error ? err.message : String(err)}`,
+    };
+  }
+}
+
+/**
+ * Clean up temporary image file
+ * @param imagePath Path to the image file to clean up
+ */
+export function cleanupTempImage(imagePath: string): void {
+  try {
+    if (existsSync(imagePath)) {
+      unlinkSync(imagePath);
+    }
+  } catch (error) {
+    console.warn(`Failed to cleanup temporary image file: ${imagePath}`, error);
+  }
+}
+
+/**
+ * Check if clipboard contains image (quick check, does not save file)
+ * @returns Promise<boolean> Whether it contains image
+ */
+export async function hasClipboardImage(): Promise<boolean> {
+  try {
+    const platform = process.platform;
+
+    if (platform === "darwin") {
+      return await hasClipboardImageMac();
+    } else if (platform === "win32") {
+      return await hasClipboardImageWindows();
+    } else if (platform === "linux") {
+      return await hasClipboardImageLinux();
+    } else {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if clipboard contains image on macOS
+ */
+async function hasClipboardImageMac(): Promise<boolean> {
+  try {
+    const { exec } = await import("child_process");
+    const { promisify } = await import("util");
+    const execAsync = promisify(exec);
+
+    const checkScript = `
+      tell application "System Events"
+        try
+          set imageData to the clipboard as «class PNGf»
+          return true
+        on error
+          return false
+        end try
+      end tell
+    `;
+
+    const { stdout } = await execAsync(`osascript -e '${checkScript}'`);
+    return stdout.trim() === "true";
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if clipboard contains image on Windows
+ */
+async function hasClipboardImageWindows(): Promise<boolean> {
+  try {
+    const { exec } = await import("child_process");
+    const { promisify } = await import("util");
+    const execAsync = promisify(exec);
+
+    const checkScript = `
+      Add-Type -AssemblyName System.Windows.Forms
+      if ([System.Windows.Forms.Clipboard]::ContainsImage()) {
+        Write-Output "true"
+      } else {
+        Write-Output "false"
+      }
+    `;
+
+    const { stdout } = await execAsync(`powershell -Command "${checkScript}"`);
+    return stdout.trim() === "true";
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if clipboard contains image on Linux
+ */
+async function hasClipboardImageLinux(): Promise<boolean> {
+  try {
+    const { exec } = await import("child_process");
+    const { promisify } = await import("util");
+    const execAsync = promisify(exec);
+
+    // Check if xclip is available
+    try {
+      await execAsync("which xclip");
+    } catch {
+      return false;
+    }
+
+    // Check if clipboard contains image
+    try {
+      await execAsync(
+        "xclip -selection clipboard -t image/png -o > /dev/null 2>&1",
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+}

package/src/utils/constants.ts

@@ -0,0 +1,22 @@
+/**
+ * Application constants definition
+ */
+
+import path from "path";
+import os from "os";
+
+/**
+ * Application data storage directory
+ * Used to store debug logs, command history and other data
+ */
+export const DATA_DIRECTORY = path.join(os.homedir(), ".wave");
+
+/**
+ * Application log file path
+ */
+export const LOG_FILE = path.join(DATA_DIRECTORY, "app.log");
+
+/**
+ * Pagination related constants
+ */
+export const MESSAGES_PER_PAGE = 20; // Number of messages displayed per page

package/src/utils/logger.ts

@@ -0,0 +1,301 @@
+/**
+ * Logger utility module
+ * Supports filtering by log level and keywords
+ * Logs are written to files instead of terminal to avoid being cleared by Ink app
+ *
+ * Performance optimization:
+ * - In test environment, you can disable all file and console I/O operations by setting environment variable DISABLE_LOGGER_IO=true
+ * - This can significantly improve test execution performance by avoiding unnecessary disk writes
+ */
+
+import * as fs from "fs";
+import { LOG_FILE, DATA_DIRECTORY } from "./constants.js";
+
+const logFile = process.env.LOG_FILE || LOG_FILE;
+
+/**
+ * Log level enumeration
+ */
+export enum LogLevel {
+  DEBUG = 0,
+  INFO = 1,
+  WARN = 2,
+  ERROR = 3,
+}
+
+/**
+ * Log level name mapping
+ */
+const LOG_LEVEL_NAMES = {
+  [LogLevel.DEBUG]: "DEBUG",
+  [LogLevel.INFO]: "INFO",
+  [LogLevel.WARN]: "WARN",
+  [LogLevel.ERROR]: "ERROR",
+};
+
+/**
+ * Log configuration interface
+ */
+interface LogConfig {
+  readonly level: LogLevel;
+  readonly keywords: string[];
+}
+
+/**
+ * Parse log level from environment variable
+ */
+const parseLogLevel = (levelStr: string | undefined): LogLevel => {
+  if (!levelStr) return LogLevel.INFO;
+
+  const upperLevel = levelStr.toUpperCase();
+  switch (upperLevel) {
+    case "DEBUG":
+      return LogLevel.DEBUG;
+    case "INFO":
+      return LogLevel.INFO;
+    case "WARN":
+      return LogLevel.WARN;
+    case "ERROR":
+      return LogLevel.ERROR;
+    default:
+      return LogLevel.INFO;
+  }
+};
+
+/**
+ * Parse keyword filter from environment variable
+ */
+const parseKeywords = (keywordsStr: string | undefined): string[] => {
+  if (!keywordsStr) return [];
+  return keywordsStr
+    .split(",")
+    .map((k) => k.trim().toLowerCase())
+    .filter((k) => k.length > 0);
+};
+
+/**
+ * Load log configuration from environment variables
+ *
+ * Supported environment variables:
+ * - LOG_LEVEL: Log level (DEBUG, INFO, WARN, ERROR), default INFO
+ * - LOG_KEYWORDS: Keyword filter, comma-separated, default no filter
+ */
+const logConfig: LogConfig = {
+  level: parseLogLevel(process.env.LOG_LEVEL),
+  keywords: parseKeywords(process.env.LOG_KEYWORDS),
+};
+
+/**
+ * Check if log should be recorded
+ */
+const shouldLog = (level: LogLevel, message: string): boolean => {
+  // Check log level
+  if (level < logConfig.level) {
+    return false;
+  }
+
+  // If no keyword filter is set, record all logs that meet the level requirement
+  if (logConfig.keywords.length === 0) {
+    return true;
+  }
+
+  // Check keyword filter
+  const lowerMessage = message.toLowerCase();
+  return logConfig.keywords.some((keyword) => lowerMessage.includes(keyword));
+};
+
+/**
+ * Format log arguments
+ */
+const formatArg = (arg: unknown): string => {
+  if (arg === null) return "null";
+  if (arg === undefined) return "undefined";
+
+  if (arg instanceof Error) {
+    // Special handling for Error objects, display stack or message
+    return arg.stack || arg.message || String(arg);
+  }
+
+  if (typeof arg === "object") {
+    try {
+      return JSON.stringify(arg, null, 2);
+    } catch {
+      // If JSON.stringify fails, fallback to String()
+      return String(arg);
+    }
+  }
+
+  return String(arg);
+};
+
+/**
+ * Generic log output function
+ */
+const logMessage = (level: LogLevel, ...args: unknown[]): void => {
+  const messageText = args.map(formatArg).join(" ");
+
+  // Check if this log should be recorded
+  if (!shouldLog(level, messageText)) {
+    return;
+  }
+
+  // If logger I/O operations are disabled, return directly to save performance
+  if (process.env.DISABLE_LOGGER_IO === "true") {
+    return;
+  }
+
+  const levelName = LOG_LEVEL_NAMES[level];
+  const timestamp = new Date().toISOString();
+  const formattedMessage = `[${timestamp}] [${levelName}] ${messageText}\n`;
+
+  try {
+    // Ensure directory exists
+    if (!fs.existsSync(DATA_DIRECTORY)) {
+      fs.mkdirSync(DATA_DIRECTORY, { recursive: true });
+    }
+
+    // Write log to file
+    fs.appendFileSync(logFile, formattedMessage);
+  } catch (error) {
+    // If file write fails, fallback to stderr
+    process.stderr.write(
+      `[${levelName}] Failed to write to log file: ${error}\n`,
+    );
+    process.stderr.write(formattedMessage);
+  }
+};
+
+/**
+ * Logger object
+ */
+export const logger = {
+  /**
+   * Debug log output function
+   */
+  debug: (...args: unknown[]): void => {
+    logMessage(LogLevel.DEBUG, ...args);
+  },
+
+  /**
+   * Info log output function
+   */
+  info: (...args: unknown[]): void => {
+    logMessage(LogLevel.INFO, ...args);
+  },
+
+  /**
+   * Warning log output function
+   */
+  warn: (...args: unknown[]): void => {
+    logMessage(LogLevel.WARN, ...args);
+  },
+
+  /**
+   * Error log output function
+   */
+  error: (...args: unknown[]): void => {
+    logMessage(LogLevel.ERROR, ...args);
+  },
+};
+
+/**
+ * Get current log configuration
+ */
+export const getLogConfig = (): LogConfig => {
+  return logConfig;
+};
+
+/**
+ * Get log file path
+ */
+export const getLogFile = (): string => {
+  return logFile;
+};
+
+/**
+ * Log cleanup configuration
+ */
+interface LogCleanupConfig {
+  /** Maximum size of current log file (bytes), default 10MB */
+  maxFileSize: number;
+  /** Number of lines to keep when truncating, default 1000 lines */
+  keepLines: number;
+}
+
+/**
+ * Get log cleanup configuration
+ * Can override default configuration with environment variables
+ */
+const getCleanupConfig = (): LogCleanupConfig => {
+  return {
+    maxFileSize: parseInt(process.env.LOG_MAX_FILE_SIZE || "10485760", 10), // 10MB
+    keepLines: parseInt(process.env.LOG_KEEP_LINES || "1000", 10),
+  };
+};
+
+/**
+ * Truncate current log file if too large
+ * Keep the last specified number of lines
+ */
+const truncateLogFileIfNeeded = (config: LogCleanupConfig): void => {
+  // If logger I/O operations are disabled, return directly to save performance
+  if (process.env.DISABLE_LOGGER_IO === "true") {
+    return;
+  }
+
+  try {
+    if (!fs.existsSync(logFile)) {
+      return;
+    }
+
+    const stats = fs.statSync(logFile);
+
+    // If file size exceeds limit, truncate file
+    if (stats.size > config.maxFileSize) {
+      const content = fs.readFileSync(logFile, "utf8");
+      const lines = content.split("\n");
+
+      // Keep the last specified number of lines
+      const keepLines = Math.min(config.keepLines, lines.length);
+      const truncatedContent = lines.slice(-keepLines).join("\n");
+
+      // Write truncated content
+      fs.writeFileSync(logFile, truncatedContent);
+
+      // Record truncation operation
+      const removedLines = lines.length - keepLines;
+      logger.info(
+        `Log file truncated: removed ${removedLines} lines, kept last ${keepLines} lines`,
+      );
+    }
+  } catch (error) {
+    logger.warn("Failed to truncate log file:", error);
+  }
+};
+
+/**
+ * Execute log cleanup
+ * Truncate current log file (if needed)
+ *
+ * @param customConfig Custom cleanup configuration, if not provided uses default configuration
+ */
+export const cleanupLogs = async (
+  customConfig?: Partial<LogCleanupConfig>,
+): Promise<void> => {
+  // If logger I/O operations are disabled, return directly to save performance
+  if (process.env.DISABLE_LOGGER_IO === "true") {
+    return;
+  }
+
+  const config = { ...getCleanupConfig(), ...customConfig };
+
+  logger.info("Starting log cleanup...", {
+    maxFileSize: config.maxFileSize,
+    keepLines: config.keepLines,
+  });
+
+  // Truncate current log file (if needed)
+  truncateLogFileIfNeeded(config);
+
+  logger.info("Log cleanup completed");
+};