fss-link 1.0.40 → 1.0.45

package/dist/ui/utils/TableRenderer.tsx

@@ -0,0 +1,159 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React from 'react';
+import { Text, Box } from 'ink';
+import { Colors } from '../colors.js';
+import { RenderInline, getPlainTextLength } from './InlineMarkdownRenderer.js';
+
+interface TableRendererProps {
+  headers: string[];
+  rows: string[][];
+  terminalWidth: number;
+}
+
+/**
+ * Custom table renderer for markdown tables
+ * We implement our own instead of using ink-table due to module compatibility issues
+ */
+export const TableRenderer: React.FC<TableRendererProps> = ({
+  headers,
+  rows,
+  terminalWidth,
+}) => {
+  // Calculate column widths using actual display width after markdown processing
+  const columnWidths = headers.map((header, index) => {
+    const headerWidth = getPlainTextLength(header);
+    const maxRowWidth = Math.max(
+      ...rows.map((row) => getPlainTextLength(row[index] || '')),
+    );
+    return Math.max(headerWidth, maxRowWidth) + 2; // Add padding
+  });
+
+  // Ensure table fits within terminal width
+  const totalWidth = columnWidths.reduce((sum, width) => sum + width + 1, 1);
+  const scaleFactor =
+    totalWidth > terminalWidth ? terminalWidth / totalWidth : 1;
+  const adjustedWidths = columnWidths.map((width) =>
+    Math.floor(width * scaleFactor),
+  );
+
+  // Helper function to render a cell with proper width
+  const renderCell = (
+    content: string,
+    width: number,
+    isHeader = false,
+  ): React.ReactNode => {
+    const contentWidth = Math.max(0, width - 2);
+    const displayWidth = getPlainTextLength(content);
+
+    let cellContent = content;
+    if (displayWidth > contentWidth) {
+      if (contentWidth <= 3) {
+        // Just truncate by character count
+        cellContent = content.substring(
+          0,
+          Math.min(content.length, contentWidth),
+        );
+      } else {
+        // Truncate preserving markdown formatting using binary search
+        let left = 0;
+        let right = content.length;
+        let bestTruncated = content;
+
+        // Binary search to find the optimal truncation point
+        while (left <= right) {
+          const mid = Math.floor((left + right) / 2);
+          const candidate = content.substring(0, mid);
+          const candidateWidth = getPlainTextLength(candidate);
+
+          if (candidateWidth <= contentWidth - 3) {
+            bestTruncated = candidate;
+            left = mid + 1;
+          } else {
+            right = mid - 1;
+          }
+        }
+
+        cellContent = bestTruncated + '...';
+      }
+    }
+
+    // Calculate exact padding needed
+    const actualDisplayWidth = getPlainTextLength(cellContent);
+    const paddingNeeded = Math.max(0, contentWidth - actualDisplayWidth);
+
+    return (
+      <Text>
+        {isHeader ? (
+          <Text bold color={Colors.AccentCyan}>
+            <RenderInline text={cellContent} />
+          </Text>
+        ) : (
+          <RenderInline text={cellContent} />
+        )}
+        {' '.repeat(paddingNeeded)}
+      </Text>
+    );
+  };
+
+  // Helper function to render border
+  const renderBorder = (type: 'top' | 'middle' | 'bottom'): React.ReactNode => {
+    const chars = {
+      top: { left: '┌', middle: '┬', right: '┐', horizontal: '─' },
+      middle: { left: '├', middle: '┼', right: '┤', horizontal: '─' },
+      bottom: { left: '└', middle: '┴', right: '┘', horizontal: '─' },
+    };
+
+    const char = chars[type];
+    const borderParts = adjustedWidths.map((w) => char.horizontal.repeat(w));
+    const border = char.left + borderParts.join(char.middle) + char.right;
+
+    return <Text>{border}</Text>;
+  };
+
+  // Helper function to render a table row
+  const renderRow = (cells: string[], isHeader = false): React.ReactNode => {
+    const renderedCells = cells.map((cell, index) => {
+      const width = adjustedWidths[index] || 0;
+      return renderCell(cell || '', width, isHeader);
+    });
+
+    return (
+      <Text>
+        │{' '}
+        {renderedCells.map((cell, index) => (
+          <React.Fragment key={index}>
+            {cell}
+            {index < renderedCells.length - 1 ? ' │ ' : ''}
+          </React.Fragment>
+        ))}{' '}
+        │
+      </Text>
+    );
+  };
+
+  return (
+    <Box flexDirection="column" marginY={1}>
+      {/* Top border */}
+      {renderBorder('top')}
+
+      {/* Header row */}
+      {renderRow(headers, true)}
+
+      {/* Middle border */}
+      {renderBorder('middle')}
+
+      {/* Data rows */}
+      {rows.map((row, index) => (
+        <React.Fragment key={index}>{renderRow(row)}</React.Fragment>
+      ))}
+
+      {/* Bottom border */}
+      {renderBorder('bottom')}
+    </Box>
+  );
+};

package/dist/ui/utils/__snapshots__/MarkdownDisplay.test.tsx.snap

@@ -0,0 +1,93 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`<MarkdownDisplay /> > correctly parses a mix of markdown elements 1`] = `
+"Main Title
+
+Here is a paragraph.
+
+ - List item 1
+ - List item 2
+
+ 1 some code
+
+Another paragraph.
+"
+`;
+
+exports[`<MarkdownDisplay /> > handles a table at the end of the input 1`] = `
+"Some text before.
+| A | B |
+|---|
+| 1 | 2 |"
+`;
+
+exports[`<MarkdownDisplay /> > handles unclosed (pending) code blocks 1`] = `" 1 let y = 2;"`;
+
+exports[`<MarkdownDisplay /> > hides line numbers in code blocks when showLineNumbers is false 1`] = `" const x = 1;"`;
+
+exports[`<MarkdownDisplay /> > inserts a single space between paragraphs 1`] = `
+"Paragraph 1.
+
+Paragraph 2."
+`;
+
+exports[`<MarkdownDisplay /> > renders a fenced code block with a language 1`] = `
+" 1 const x = 1;
+ 2 console.log(x);"
+`;
+
+exports[`<MarkdownDisplay /> > renders a fenced code block without a language 1`] = `" 1 plain text"`;
+
+exports[`<MarkdownDisplay /> > renders a simple paragraph 1`] = `"Hello, world."`;
+
+exports[`<MarkdownDisplay /> > renders headers with correct levels 1`] = `
+"Header 1
+Header 2
+Header 3
+Header 4
+"
+`;
+
+exports[`<MarkdownDisplay /> > renders horizontal rules 1`] = `
+"Hello
+---
+World
+---
+Test
+"
+`;
+
+exports[`<MarkdownDisplay /> > renders nested unordered lists 1`] = `
+" * Level 1
+   * Level 2
+     * Level 3
+"
+`;
+
+exports[`<MarkdownDisplay /> > renders nothing for empty text 1`] = `""`;
+
+exports[`<MarkdownDisplay /> > renders ordered lists 1`] = `
+" 1. First item
+ 2. Second item
+"
+`;
+
+exports[`<MarkdownDisplay /> > renders tables correctly 1`] = `
+"
+┌──────────┬──────────┐
+│ Header 1 │ Header 2 │
+├──────────┼──────────┤
+│ Cell 1   │ Cell 2   │
+│ Cell 3   │ Cell 4   │
+└──────────┴──────────┘
+"
+`;
+
+exports[`<MarkdownDisplay /> > renders unordered lists with different markers 1`] = `
+" - item A
+ * item B
+ + item C
+"
+`;
+
+exports[`<MarkdownDisplay /> > shows line numbers in code blocks by default 1`] = `" 1 const x = 1;"`;

package/dist/ui/utils/clipboardUtils.test.ts

@@ -0,0 +1,76 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  clipboardHasImage,
+  saveClipboardImage,
+  cleanupOldClipboardImages,
+} from './clipboardUtils.js';
+
+describe('clipboardUtils', () => {
+  describe('clipboardHasImage', () => {
+    it('should return false on non-macOS platforms', async () => {
+      if (process.platform !== 'darwin') {
+        const result = await clipboardHasImage();
+        expect(result).toBe(false);
+      } else {
+        // Skip on macOS as it would require actual clipboard state
+        expect(true).toBe(true);
+      }
+    });
+
+    it('should return boolean on macOS', async () => {
+      if (process.platform === 'darwin') {
+        const result = await clipboardHasImage();
+        expect(typeof result).toBe('boolean');
+      } else {
+        // Skip on non-macOS
+        expect(true).toBe(true);
+      }
+    });
+  });
+
+  describe('saveClipboardImage', () => {
+    it('should return null on non-macOS platforms', async () => {
+      if (process.platform !== 'darwin') {
+        const result = await saveClipboardImage();
+        expect(result).toBe(null);
+      } else {
+        // Skip on macOS
+        expect(true).toBe(true);
+      }
+    });
+
+    it('should handle errors gracefully', async () => {
+      // Test with invalid directory (should not throw)
+      const result = await saveClipboardImage(
+        '/invalid/path/that/does/not/exist',
+      );
+
+      if (process.platform === 'darwin') {
+        // On macOS, might return null due to various errors
+        expect(result === null || typeof result === 'string').toBe(true);
+      } else {
+        // On other platforms, should always return null
+        expect(result).toBe(null);
+      }
+    });
+  });
+
+  describe('cleanupOldClipboardImages', () => {
+    it('should not throw errors', async () => {
+      // Should handle missing directories gracefully
+      await expect(
+        cleanupOldClipboardImages('/path/that/does/not/exist'),
+      ).resolves.not.toThrow();
+    });
+
+    it('should complete without errors on valid directory', async () => {
+      await expect(cleanupOldClipboardImages('.')).resolves.not.toThrow();
+    });
+  });
+});

package/dist/ui/utils/clipboardUtils.ts

@@ -0,0 +1,149 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+const execAsync = promisify(exec);
+
+/**
+ * Checks if the system clipboard contains an image (macOS only for now)
+ * @returns true if clipboard contains an image
+ */
+export async function clipboardHasImage(): Promise<boolean> {
+  if (process.platform !== 'darwin') {
+    return false;
+  }
+
+  try {
+    // Use osascript to check clipboard type
+    const { stdout } = await execAsync(
+      `osascript -e 'clipboard info' 2>/dev/null | grep -qE "«class PNGf»|TIFF picture|JPEG picture|GIF picture|«class JPEG»|«class TIFF»" && echo "true" || echo "false"`,
+      { shell: '/bin/bash' },
+    );
+    return stdout.trim() === 'true';
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Saves the image from clipboard to a temporary file (macOS only for now)
+ * @param targetDir The target directory to create temp files within
+ * @returns The path to the saved image file, or null if no image or error
+ */
+export async function saveClipboardImage(
+  targetDir?: string,
+): Promise<string | null> {
+  if (process.platform !== 'darwin') {
+    return null;
+  }
+
+  try {
+    // Create a temporary directory for clipboard images within the target directory
+    // This avoids security restrictions on paths outside the target directory
+    const baseDir = targetDir || process.cwd();
+    const tempDir = path.join(baseDir, '.gemini-clipboard');
+    await fs.mkdir(tempDir, { recursive: true });
+
+    // Generate a unique filename with timestamp
+    const timestamp = new Date().getTime();
+
+    // Try different image formats in order of preference
+    const formats = [
+      { class: 'PNGf', extension: 'png' },
+      { class: 'JPEG', extension: 'jpg' },
+      { class: 'TIFF', extension: 'tiff' },
+      { class: 'GIFf', extension: 'gif' },
+    ];
+
+    for (const format of formats) {
+      const tempFilePath = path.join(
+        tempDir,
+        `clipboard-${timestamp}.${format.extension}`,
+      );
+
+      // Try to save clipboard as this format
+      const script = `
+        try
+          set imageData to the clipboard as «class ${format.class}»
+          set fileRef to open for access POSIX file "${tempFilePath}" with write permission
+          write imageData to fileRef
+          close access fileRef
+          return "success"
+        on error errMsg
+          try
+            close access POSIX file "${tempFilePath}"
+          end try
+          return "error"
+        end try
+      `;
+
+      const { stdout } = await execAsync(`osascript -e '${script}'`);
+
+      if (stdout.trim() === 'success') {
+        // Verify the file was created and has content
+        try {
+          const stats = await fs.stat(tempFilePath);
+          if (stats.size > 0) {
+            return tempFilePath;
+          }
+        } catch {
+          // File doesn't exist, continue to next format
+        }
+      }
+
+      // Clean up failed attempt
+      try {
+        await fs.unlink(tempFilePath);
+      } catch {
+        // Ignore cleanup errors
+      }
+    }
+
+    // No format worked
+    return null;
+  } catch (error) {
+    console.error('Error saving clipboard image:', error);
+    return null;
+  }
+}
+
+/**
+ * Cleans up old temporary clipboard image files
+ * Removes files older than 1 hour
+ * @param targetDir The target directory where temp files are stored
+ */
+export async function cleanupOldClipboardImages(
+  targetDir?: string,
+): Promise<void> {
+  try {
+    const baseDir = targetDir || process.cwd();
+    const tempDir = path.join(baseDir, '.gemini-clipboard');
+    const files = await fs.readdir(tempDir);
+    const oneHourAgo = Date.now() - 60 * 60 * 1000;
+
+    for (const file of files) {
+      if (
+        file.startsWith('clipboard-') &&
+        (file.endsWith('.png') ||
+          file.endsWith('.jpg') ||
+          file.endsWith('.tiff') ||
+          file.endsWith('.gif'))
+      ) {
+        const filePath = path.join(tempDir, file);
+        const stats = await fs.stat(filePath);
+        if (stats.mtimeMs < oneHourAgo) {
+          await fs.unlink(filePath);
+        }
+      }
+    }
+  } catch {
+    // Ignore errors in cleanup
+  }
+}