copyhub-cli 1.0.1 → 1.0.4

package/src/start-daemon-logic.js

@@ -1,4 +1,4 @@
-import { appendHistory } from './storage.js';
+import { appendHistory, isDuplicateOfLatestHistory } from './storage.js';
 import { startClipboardWatcher } from './clipboard-watcher.js';
 import { appendClipboardToSheet } from './sheets.js';
 import { loadTokens } from './tokens.js';
@@ -73,6 +73,9 @@ export async function runCopyhubDaemon(opts, io = console) {
   let lastSheetLogAt = 0;
 
   const watcher = startClipboardWatcher(async (text) => {
+    if (isDuplicateOfLatestHistory(text)) {
+      return;
+    }
     let synced = false;
     if (useSheet && sheetTarget && (tokens?.refresh_token || tokens?.access_token)) {
       try {

package/src/storage.js

@@ -57,3 +57,14 @@ export function readRecentHistorySync(maxLines = 200) {
   }
   return out.reverse();
 }
+
+/**
+ * True when `text` equals the latest saved history row (skip consecutive identical copies).
+ * @param {string} text
+ */
+export function isDuplicateOfLatestHistory(text) {
+  if (typeof text !== 'string' || text.length === 0) return false;
+  const recent = readRecentHistorySync(1);
+  const last = recent[0];
+  return typeof last?.text === 'string' && last.text === text;
+}

package/src/wipe-data.js

@@ -0,0 +1,10 @@
+import { rm } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { DIR } from './paths.js';
+
+/** Delete the entire ~/.copyhub directory (all local CopyHub data). */
+export async function wipeCopyhubDirectory() {
+  if (existsSync(DIR)) {
+    await rm(DIR, { recursive: true, force: true });
+  }
+}

package/ui/main.mjs

@@ -1,4 +1,3 @@
-import 'dotenv/config';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import {
@@ -12,8 +11,16 @@ import {
   Menu,
   nativeImage,
 } from 'electron';
+import { loadCopyhubEnv } from '../src/load-env.js';
 import { readRecentHistorySync } from '../src/storage.js';
-import { loadOverlayAcceleratorFromConfigSync } from '../src/config.js';
+import {
+  loadOverlayAcceleratorFromConfigSync,
+  loadSheetSyncTarget,
+} from '../src/config.js';
+import { loadTokens } from '../src/tokens.js';
+import { fetchOverlayDailyTabRows } from '../src/sheet-overlay-history.js';
+
+loadCopyhubEnv();
 
 const gotLock = app.requestSingleInstanceLock();
 if (!gotLock) {
@@ -38,8 +45,9 @@ function normalizeAccelerator(raw) {
 const DEFAULT_ACCEL = 'CommandOrControl+Shift+H';
 const HIDE_ON_START = process.env.COPYHUB_OVERLAY_HIDE_ON_START === '1';
 
-/** Overlay width (~70% of 460px baseline). */
-const OVERLAY_WIDTH = Math.round(460 * 0.7);
+/** Overlay size (slightly larger than earlier ~70% width). */
+const OVERLAY_WIDTH = Math.round(460 * 0.84);
+const OVERLAY_HEIGHT = 590;
 
 /** For UI / IPC: registered shortcut and raw value from .env */
 let overlayHotkeyMeta = {
@@ -53,6 +61,27 @@ let tray = null;
 /** Avoid hiding immediately after show (WM quirks). */
 let blurHideEnabled = false;
 
+/**
+ * After showing the overlay, enable blur→hide after a short grace period so clicks outside close it reliably.
+ * @param {BrowserWindow} w
+ */
+function armBlurHideEnable(w) {
+  if (STICKY_NO_BLUR || !w || w.isDestroyed()) return;
+  blurHideEnabled = false;
+  let armed = false;
+  const arm = () => {
+    if (armed || !w || w.isDestroyed()) return;
+    armed = true;
+    setTimeout(() => {
+      if (!STICKY_NO_BLUR && w && !w.isDestroyed()) {
+        blurHideEnabled = true;
+      }
+    }, 320);
+  };
+  w.once('focus', arm);
+  setTimeout(arm, 420);
+}
+
 /**
  * Stay above other apps: screen-saver level (highest in Electron), moveTop, all workspaces.
  * @param {BrowserWindow} w
@@ -85,7 +114,7 @@ function applyAlwaysOnTopStack(w) {
 function createWindow() {
   win = new BrowserWindow({
     width: OVERLAY_WIDTH,
-    height: 540,
+    height: OVERLAY_HEIGHT,
     alwaysOnTop: true,
     show: false,
     /** Frameless: no title bar + menu (Windows/macOS). */
@@ -138,10 +167,8 @@ function createWindow() {
     applyAlwaysOnTopStack(win);
     win.focus();
     win.webContents.send('overlay:open');
-    setTimeout(() => {
-      applyAlwaysOnTopStack(win);
-      blurHideEnabled = true;
-    }, 800);
+    setTimeout(() => applyAlwaysOnTopStack(win), 120);
+    armBlurHideEnable(win);
   });
 }
 
@@ -180,10 +207,8 @@ function toggleOverlay() {
     applyAlwaysOnTopStack(win);
     win.focus();
     win.webContents.send('overlay:open');
-    setTimeout(() => {
-      applyAlwaysOnTopStack(win);
-      blurHideEnabled = true;
-    }, 800);
+    setTimeout(() => applyAlwaysOnTopStack(win), 120);
+    armBlurHideEnable(win);
   }
 }
 
@@ -222,6 +247,169 @@ function registerHotkeys() {
   return { accelerator: '', usedFallback: false };
 }
 
+function mergeHistoryForOverlay(localItems, sheetItems, cap) {
+  const seen = new Set();
+  /** @type {typeof localItems} */
+  const out = [];
+  /** Sheet rows first so duplicates dedupe keeps sheet metadata when timestamps tie. */
+  const combined = [...sheetItems, ...localItems];
+  combined.sort((a, b) => (Date.parse(b.ts) || 0) - (Date.parse(a.ts) || 0));
+  for (const it of combined) {
+    const key = `${it.ts}\u0000${it.text}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(it);
+  }
+  return out.slice(0, cap);
+}
+
+/** @type {{ merged: Array<{ ts: string, text: string, synced: boolean }> }} */
+const historyMergedCache = {
+  merged: [],
+};
+
+/** Recent local lines only — Sheet supplies older / cross-device rows so they are not crowded out. */
+const HISTORY_LOCAL_LINES = 700;
+/** Max merged entries after dedupe (pagination slices this list). */
+const HISTORY_MERGE_CAP = 4000;
+
+/** @type {{ sheetFetched: number, sheetHint: string }} */
+let lastHistorySheetMeta = { sheetFetched: 0, sheetHint: '' };
+
+/** Sequential Sheet fetch: one daily tab per step until overlay has enough merged rows. */
+let sheetIncrementalState = {
+  accumulatedItems: [],
+  nextDaysAgo: 0,
+  daysBackLimit: 30,
+  exhausted: false,
+  maxRowsPerTab: 500,
+};
+
+function resetSheetIncrementalState() {
+  sheetIncrementalState = {
+    accumulatedItems: [],
+    nextDaysAgo: 0,
+    daysBackLimit: 30,
+    exhausted: false,
+    maxRowsPerTab: 500,
+  };
+}
+
+async function fetchNextDailyTabIntoState() {
+  if (sheetIncrementalState.exhausted) return;
+  if (sheetIncrementalState.nextDaysAgo > sheetIncrementalState.daysBackLimit) {
+    sheetIncrementalState.exhausted = true;
+    return;
+  }
+  try {
+    const items = await fetchOverlayDailyTabRows(
+      sheetIncrementalState.nextDaysAgo,
+      sheetIncrementalState.maxRowsPerTab,
+    );
+    sheetIncrementalState.accumulatedItems.push(...items);
+    sheetIncrementalState.accumulatedItems.sort(
+      (a, b) => (Date.parse(b.ts) || 0) - (Date.parse(a.ts) || 0),
+    );
+    if (sheetIncrementalState.accumulatedItems.length > HISTORY_MERGE_CAP) {
+      sheetIncrementalState.accumulatedItems =
+        sheetIncrementalState.accumulatedItems.slice(0, HISTORY_MERGE_CAP);
+    }
+  } catch (e) {
+    const msg = /** @type {Error} */ (e).message || String(e);
+    lastHistorySheetMeta.sheetHint = `Google Sheet error: ${msg.slice(0, 140)}`;
+    console.warn('[CopyHub overlay]', lastHistorySheetMeta.sheetHint);
+    sheetIncrementalState.exhausted = true;
+    return;
+  }
+  sheetIncrementalState.nextDaysAgo += 1;
+}
+
+/**
+ * Ensure merged history covers at least `page * pageSize` items (capped), fetching extra Sheet tabs only if needed.
+ */
+async function ensureMergedHistoryCoversPage(page, pageSize) {
+  const localItems = buildLocalHistoryItems();
+  const sheetTarget = await loadSheetSyncTarget();
+  const tok = await loadTokens();
+  const sheetOk =
+    Boolean(sheetTarget) && Boolean(tok?.refresh_token || tok?.access_token);
+
+  if (!sheetOk) {
+    if (!sheetTarget) {
+      lastHistorySheetMeta = {
+        sheetFetched: 0,
+        sheetHint: 'Google Sheet: not configured — run copyhub login',
+      };
+    } else {
+      lastHistorySheetMeta = {
+        sheetFetched: 0,
+        sheetHint: 'Google Sheet: not signed in — run copyhub login',
+      };
+    }
+    sheetIncrementalState.exhausted = true;
+    historyMergedCache.merged = mergeHistoryForOverlay(localItems, [], HISTORY_MERGE_CAP);
+    return;
+  }
+
+  const targetMin = Math.min(page * pageSize, HISTORY_MERGE_CAP);
+
+  while (true) {
+    const merged = mergeHistoryForOverlay(
+      localItems,
+      sheetIncrementalState.accumulatedItems,
+      HISTORY_MERGE_CAP,
+    );
+    historyMergedCache.merged = merged;
+
+    if (merged.length >= HISTORY_MERGE_CAP) break;
+    if (sheetIncrementalState.exhausted) break;
+    /** Merge Sheet at least once when configured so dedupe / synced flags match Sheet. */
+    if (merged.length >= targetMin && sheetIncrementalState.nextDaysAgo > 0) break;
+
+    await fetchNextDailyTabIntoState();
+  }
+
+  const preservedErr =
+    typeof lastHistorySheetMeta.sheetHint === 'string' &&
+    lastHistorySheetMeta.sheetHint.startsWith('Google Sheet error:');
+
+  lastHistorySheetMeta.sheetFetched = sheetIncrementalState.accumulatedItems.length;
+
+  if (!preservedErr) {
+    if (!sheetIncrementalState.exhausted) {
+      lastHistorySheetMeta.sheetHint = `Google Sheet: ${sheetIncrementalState.accumulatedItems.length} rows · more when you page`;
+    } else if (sheetIncrementalState.accumulatedItems.length === 0) {
+      lastHistorySheetMeta.sheetHint =
+        'Google Sheet: 0 rows in last 31 days (check COPYHUB-YYYY-MM-DD tabs / timezone)';
+    } else {
+      lastHistorySheetMeta.sheetHint = `Google Sheet: ${sheetIncrementalState.accumulatedItems.length} rows loaded`;
+    }
+  }
+}
+
+function buildLocalHistoryItems() {
+  return readRecentHistorySync(HISTORY_LOCAL_LINES).map((row) => ({
+    ts: row.ts || '',
+    text: typeof row.text === 'string' ? row.text : '',
+    synced: Boolean(row.syncedToSheet || row.syncedToGmail),
+  }));
+}
+
+/** @param {ReturnType<typeof buildLocalHistoryItems>} items */
+function paginateHistoryItems(items, page, pageSize) {
+  const total = items.length;
+  const totalPages = Math.max(1, Math.ceil(total / pageSize));
+  const safePage = Math.min(Math.max(page, 1), totalPages);
+  const start = (safePage - 1) * pageSize;
+  return {
+    items: items.slice(start, start + pageSize),
+    page: safePage,
+    pageSize,
+    total,
+    totalPages,
+  };
+}
+
 function registerIpc() {
   ipcMain.handle('overlay:meta', () => ({
     ...overlayHotkeyMeta,
@@ -230,17 +418,81 @@ function registerIpc() {
     sticky: STICKY_NO_BLUR,
   }));
 
-  ipcMain.handle('history:get', () => {
+  /** Fast path: local history.jsonl only (overlay shows this while Sheet loads). */
+  ipcMain.handle('history:getLocal', (_e, opts = {}) => {
+    try {
+      const pageSize = Math.min(Math.max(Number(opts.pageSize) || 10, 1), 50);
+      let page = Math.max(Number(opts.page) || 1, 1);
+      const localItems = buildLocalHistoryItems();
+      const paginated = paginateHistoryItems(localItems, page, pageSize);
+      return {
+        ...paginated,
+        provisional: true,
+        sheetHint:
+          localItems.length > 0
+            ? 'Showing local copies · loading Google Sheet…'
+            : 'Loading Google Sheet…',
+        sheetFetched: 0,
+        sheetHasMore: false,
+      };
+    } catch (e) {
+      return {
+        error: /** @type {Error} */ (e).message,
+        items: [],
+        page: 1,
+        pageSize: 10,
+        total: 0,
+        totalPages: 1,
+        provisional: true,
+        sheetHint: '',
+        sheetFetched: 0,
+        sheetHasMore: false,
+      };
+    }
+  });
+
+  ipcMain.handle('history:get', async (_e, opts = {}) => {
     try {
+      const pageSize = Math.min(Math.max(Number(opts.pageSize) || 10, 1), 50);
+      let page = Math.max(Number(opts.page) || 1, 1);
+      const refresh = Boolean(opts.refresh);
+
+      if (refresh) {
+        resetSheetIncrementalState();
+        lastHistorySheetMeta = { sheetFetched: 0, sheetHint: '' };
+        historyMergedCache.merged = [];
+      }
+
+      await ensureMergedHistoryCoversPage(page, pageSize);
+
+      const total = historyMergedCache.merged.length;
+      const totalPages = Math.max(1, Math.ceil(total / pageSize));
+      page = Math.min(page, totalPages);
+      const start = (page - 1) * pageSize;
+      const items = historyMergedCache.merged.slice(start, start + pageSize);
+
       return {
-        items: readRecentHistorySync(200).map((row) => ({
-          ts: row.ts || '',
-          text: typeof row.text === 'string' ? row.text : '',
-          synced: Boolean(row.syncedToSheet || row.syncedToGmail),
-        })),
+        items,
+        page,
+        pageSize,
+        total,
+        totalPages,
+        sheetHint: lastHistorySheetMeta.sheetHint,
+        sheetFetched: lastHistorySheetMeta.sheetFetched,
+        sheetHasMore: !sheetIncrementalState.exhausted,
       };
     } catch (e) {
-      return { error: /** @type {Error} */ (e).message, items: [] };
+      return {
+        error: /** @type {Error} */ (e).message,
+        items: [],
+        page: 1,
+        pageSize: 10,
+        total: 0,
+        totalPages: 1,
+        sheetHint: '',
+        sheetFetched: 0,
+        sheetHasMore: false,
+      };
     }
   });
 

package/ui/preload.cjs

@@ -2,7 +2,10 @@ const { contextBridge, ipcRenderer } = require('electron');
 
 contextBridge.exposeInMainWorld('copyhub', {
   getMeta: () => ipcRenderer.invoke('overlay:meta'),
-  getHistory: () => ipcRenderer.invoke('history:get'),
+  /** @param {{ page?: number, pageSize?: number, refresh?: boolean }} [opts] */
+  getHistory: (opts) => ipcRenderer.invoke('history:get', opts ?? {}),
+  /** Local history only — instant; used while Sheet sync runs. */
+  getHistoryLocal: (opts) => ipcRenderer.invoke('history:getLocal', opts ?? {}),
   copyPick: (text) => ipcRenderer.invoke('history:copy', text),
   onOpen: (fn) => {
     ipcRenderer.on('overlay:open', (_e) => {