copyhub-cli 1.0.0

package/src/sheets.js

@@ -0,0 +1,106 @@
+import { google } from 'googleapis';
+import { getAuthorizedClient } from './oauth.js';
+import { loadSheetSyncTarget } from './config.js';
+import { dailySheetTabName } from './sheet-daily.js';
+import { formatGoogleSheetUserMessage } from './sheet-api-errors.js';
+
+/**
+ * @param {string} tabName
+ */
+function a1RangeForTab(tabName) {
+  const escaped = /[^A-Za-z0-9_]/.test(tabName)
+    ? `'${tabName.replace(/'/g, "''")}'`
+    : tabName;
+  return `${escaped}!A:B`;
+}
+
+/**
+ * @param {import('googleapis').sheets_v4.Sheets} sheets
+ * @param {string} spreadsheetId
+ * @param {string} tabName
+ * @returns {Promise<boolean>} true if a new tab was created (header row written)
+ */
+async function ensureDailySheetExists(sheets, spreadsheetId, tabName) {
+  const { data } = await sheets.spreadsheets.get({
+    spreadsheetId,
+    fields: 'sheets.properties(title)',
+  });
+  const exists = data.sheets?.some((s) => s.properties?.title === tabName);
+  if (exists) return false;
+
+  try {
+    await sheets.spreadsheets.batchUpdate({
+      spreadsheetId,
+      requestBody: {
+        requests: [
+          {
+            addSheet: {
+              properties: {
+                title: tabName,
+                gridProperties: { rowCount: 5000, columnCount: 4 },
+              },
+            },
+          },
+        ],
+      },
+    });
+  } catch (e) {
+    const err = /** @type {Error & { code?: number }} */ (e);
+    const msg = `${err.message || ''} ${err.code || ''}`;
+    if (msg.includes('already exists') || err.code === 400) {
+      return false;
+    }
+    throw e;
+  }
+
+  const headerRange = a1RangeForTab(tabName).replace('!A:B', '!A1:B1');
+  await sheets.spreadsheets.values.update({
+    spreadsheetId,
+    range: headerRange,
+    valueInputOption: 'RAW',
+    requestBody: {
+      values: [['Time', 'Content']],
+    },
+  });
+  return true;
+}
+
+/**
+ * Append one row to the **daily** tab (creates a new tab each day if missing).
+ * Column A = ISO timestamp, column B = content (RAW).
+ * @param {string} clipboardText
+ */
+export async function appendClipboardToSheet(clipboardText) {
+  try {
+    const target = await loadSheetSyncTarget();
+    if (!target) {
+      throw new Error(
+        'No Spreadsheet ID. Run copyhub login (setup page) or copyhub config ... --sheet-id <ID>.',
+      );
+    }
+
+    const auth = await getAuthorizedClient();
+    if (!auth.credentials.refresh_token && !auth.credentials.access_token) {
+      throw new Error('Not signed in. Run: copyhub login');
+    }
+
+    const sheets = google.sheets({ version: 'v4', auth });
+    const tabName = dailySheetTabName();
+    await ensureDailySheetExists(sheets, target.spreadsheetId, tabName);
+
+    const range = a1RangeForTab(tabName);
+    const ts = new Date().toISOString();
+
+    await sheets.spreadsheets.values.append({
+      spreadsheetId: target.spreadsheetId,
+      range,
+      valueInputOption: 'RAW',
+      insertDataOption: 'INSERT_ROWS',
+      requestBody: {
+        values: [[ts, clipboardText]],
+      },
+    });
+  } catch (e) {
+    throw new Error(formatGoogleSheetUserMessage(e));
+  }
+}

package/src/start-daemon-logic.js

@@ -0,0 +1,114 @@
+import { appendHistory } from './storage.js';
+import { startClipboardWatcher } from './clipboard-watcher.js';
+import { appendClipboardToSheet } from './sheets.js';
+import { loadTokens } from './tokens.js';
+import { loadSheetSyncTarget } from './config.js';
+import { DIR } from './paths.js';
+import { logLinuxClipboardHint } from './platform.js';
+import { dailySheetTabName } from './sheet-daily.js';
+import { spawnCopyhubOverlay } from './electron-launcher.js';
+
+/**
+ * @typedef {{ useSheet: boolean, skipOverlay: boolean }} StartDaemonOptions
+ */
+
+/**
+ * Run clipboard watcher (+ optional overlay); logs via io (defaults to console).
+ * @param {StartDaemonOptions} opts
+ * @param {{ log: typeof console.log, warn: typeof console.warn, error: typeof console.error }} io
+ */
+export async function runCopyhubDaemon(opts, io = console) {
+  const useSheet = opts.useSheet;
+  const skipOverlay = opts.skipOverlay;
+
+  let tokens = await loadTokens();
+  const sheetTarget = await loadSheetSyncTarget();
+
+  if (useSheet && !sheetTarget) {
+    io.warn(
+      'No Spreadsheet ID in ~/.copyhub/config.json — run copyhub login or copyhub config ... --sheet-id <ID>',
+    );
+  }
+  if (useSheet && sheetTarget && !tokens?.refresh_token && !tokens?.access_token) {
+    io.warn('No OAuth token — local history only. Run copyhub login.');
+  }
+
+  io.log('CopyHub daemon running.');
+  io.log('Data directory:', DIR);
+  if (sheetTarget) {
+    io.log(`Sheet: daily tab "${dailySheetTabName()}".`);
+  }
+
+  /** @type {import('node:child_process').ChildProcess | null} */
+  let overlayProc = null;
+  let overlayStoppingWithCli = false;
+
+  if (!skipOverlay) {
+    try {
+      overlayProc = spawnCopyhubOverlay({
+        stdio: 'ignore',
+        envExtra: { COPYHUB_SPAWNED_BY_START: '1' },
+      });
+      overlayProc.on('error', (err) => {
+        io.warn('Could not start Electron overlay:', err.message);
+        overlayProc = null;
+      });
+      overlayProc.on('exit', (code, sig) => {
+        if (!overlayStoppingWithCli && code != null && code !== 0) {
+          io.warn(
+            `Electron overlay exited (code ${code}). Run copyhub overlay or restart copyhub start.`,
+          );
+        }
+        overlayProc = null;
+      });
+      io.log('Started history overlay (Electron).');
+    } catch (e) {
+      io.warn('Could not start overlay:', /** @type {Error} */ (e).message);
+    }
+  }
+
+  logLinuxClipboardHint();
+
+  let lastSheetLogKey = '';
+  let lastSheetLogAt = 0;
+
+  const watcher = startClipboardWatcher(async (text) => {
+    let synced = false;
+    if (useSheet && sheetTarget && (tokens?.refresh_token || tokens?.access_token)) {
+      try {
+        await appendClipboardToSheet(text);
+        synced = true;
+        lastSheetLogKey = '';
+        io.log(`[${new Date().toISOString()}] Appended row to Google Sheet (daily tab).`);
+      } catch (e) {
+        const msg = /** @type {Error} */ (e).message;
+        const now = Date.now();
+        const key = msg.slice(0, 160);
+        if (key !== lastSheetLogKey || now - lastSheetLogAt > 120_000) {
+          lastSheetLogKey = key;
+          lastSheetLogAt = now;
+          io.error(`[${new Date().toISOString()}] Google Sheet error:`, msg);
+        }
+      }
+    }
+    await appendHistory({ text, syncedToSheet: synced });
+    const oneLine = text.replace(/\r?\n/g, '\\n').slice(0, 120);
+    io.log(
+      `[${new Date().toISOString()}] Saved (${text.length} chars): ${oneLine}${text.length > 120 ? '…' : ''}`,
+    );
+  });
+
+  return {
+    stopSync() {
+      watcher.stop();
+      if (overlayProc && !overlayProc.killed) {
+        overlayStoppingWithCli = true;
+        try {
+          overlayProc.kill('SIGTERM');
+        } catch {
+          /* ignore */
+        }
+      }
+    },
+  };
+}

package/src/stop-process.js

@@ -0,0 +1,29 @@
+import { execSync } from 'node:child_process';
+
+/**
+ * Stop process and (Windows) entire child tree (Electron overlay).
+ * @param {number} pid
+ */
+export function killDaemonTree(pid) {
+  if (process.platform === 'win32') {
+    try {
+      execSync(`taskkill /PID ${pid} /T /F`, { stdio: 'ignore' });
+    } catch {
+      try {
+        process.kill(pid, 'SIGKILL');
+      } catch {
+        /* ignore */
+      }
+    }
+    return;
+  }
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch {
+    try {
+      process.kill(pid, 'SIGKILL');
+    } catch {
+      /* ignore */
+    }
+  }
+}

package/src/storage.js

@@ -0,0 +1,59 @@
+import { mkdir, appendFile, readFile } from 'node:fs/promises';
+import { existsSync, readFileSync } from 'node:fs';
+import { DIR, HISTORY_PATH } from './paths.js';
+
+export async function ensureDir() {
+  const opts = { recursive: true };
+  if (process.platform !== 'win32') {
+    Object.assign(opts, { mode: 0o700 });
+  }
+  await mkdir(DIR, opts);
+}
+
+/**
+ * @param {{ text: string, syncedToSheet?: boolean }} entry
+ */
+export async function appendHistory(entry) {
+  await ensureDir();
+  const line = JSON.stringify({
+    ts: new Date().toISOString(),
+    text: entry.text,
+    syncedToSheet: Boolean(entry.syncedToSheet),
+  }) + '\n';
+  await appendFile(HISTORY_PATH, line, 'utf8');
+}
+
+export async function readRecentHistory(maxLines = 50) {
+  if (!existsSync(HISTORY_PATH)) return [];
+  const raw = await readFile(HISTORY_PATH, 'utf8');
+  const lines = raw.trim().split('\n').filter(Boolean);
+  return lines.slice(-maxLines).map((l) => {
+    try {
+      return JSON.parse(l);
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
+}
+
+/**
+ * Newest items first (for Electron overlay).
+ * @param {number} [maxLines]
+ * @returns {Array<{ ts?: string, text?: string, syncedToSheet?: boolean }>}
+ */
+export function readRecentHistorySync(maxLines = 200) {
+  if (!existsSync(HISTORY_PATH)) return [];
+  const raw = readFileSync(HISTORY_PATH, 'utf8');
+  const lines = raw.trim().split('\n').filter(Boolean);
+  const slice = lines.slice(-maxLines);
+  /** @type {Array<{ ts?: string, text?: string, syncedToSheet?: boolean }>} */
+  const out = [];
+  for (const l of slice) {
+    try {
+      out.push(JSON.parse(l));
+    } catch {
+      /* skip */
+    }
+  }
+  return out.reverse();
+}

package/src/tokens.js

@@ -0,0 +1,24 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { TOKENS_PATH } from './paths.js';
+import { ensureDir } from './storage.js';
+
+/** @typedef {{ access_token?: string, refresh_token?: string, scope?: string, token_type?: string, expiry_date?: number }} TokenSet */
+
+/** @returns {Promise<TokenSet | null>} */
+export async function loadTokens() {
+  if (!existsSync(TOKENS_PATH)) return null;
+  const raw = await readFile(TOKENS_PATH, 'utf8');
+  return JSON.parse(raw);
+}
+
+/** @param {TokenSet} tokens */
+export async function saveTokens(tokens) {
+  await ensureDir();
+  await writeFile(TOKENS_PATH, JSON.stringify(tokens, null, 2), 'utf8');
+}
+
+export async function clearTokens() {
+  if (!existsSync(TOKENS_PATH)) return;
+  await writeFile(TOKENS_PATH, '{}', 'utf8');
+}

package/ui/main.mjs

@@ -0,0 +1,331 @@
+import 'dotenv/config';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  app,
+  BrowserWindow,
+  globalShortcut,
+  clipboard,
+  ipcMain,
+  screen,
+  Tray,
+  Menu,
+  nativeImage,
+} from 'electron';
+import { readRecentHistorySync } from '../src/storage.js';
+import { loadOverlayAcceleratorFromConfigSync } from '../src/config.js';
+
+const gotLock = app.requestSingleInstanceLock();
+if (!gotLock) {
+  app.quit();
+}
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/** Set to 1 so the window does not hide on blur (only Esc / pick row to copy). */
+const STICKY_NO_BLUR = process.env.COPYHUB_OVERLAY_STICKY === '1';
+
+/** Electron Accelerator: use `Control`, not `Ctrl`; `CommandOrControl` = Ctrl (Win) / Cmd (Mac). */
+function normalizeAccelerator(raw) {
+  if (!raw || typeof raw !== 'string') return '';
+  let s = raw.trim();
+  s = s.replace(/\bCtrl\b/gi, 'Control');
+  s = s.replace(/\bCmd\b/gi, 'Command');
+  s = s.replace(/\s*\+\s*/g, '+');
+  return s;
+}
+
+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);
+
+/** For UI / IPC: registered shortcut and raw value from .env */
+let overlayHotkeyMeta = {
+  accelerator: '',
+  usedFallback: false,
+  requestedRaw: '',
+};
+
+let win = null;
+let tray = null;
+/** Avoid hiding immediately after show (WM quirks). */
+let blurHideEnabled = false;
+
+/**
+ * Stay above other apps: screen-saver level (highest in Electron), moveTop, all workspaces.
+ * @param {BrowserWindow} w
+ */
+function applyAlwaysOnTopStack(w) {
+  if (!w || w.isDestroyed()) return;
+  try {
+    w.setAlwaysOnTop(true, 'screen-saver');
+  } catch {
+    try {
+      w.setAlwaysOnTop(true, 'floating');
+    } catch {
+      w.setAlwaysOnTop(true);
+    }
+  }
+  try {
+    w.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
+  } catch {
+    /* unsupported on some Linux builds */
+  }
+  try {
+    if (typeof w.moveTop === 'function') {
+      w.moveTop();
+    }
+  } catch {
+    /* ignore */
+  }
+}
+
+function createWindow() {
+  win = new BrowserWindow({
+    width: OVERLAY_WIDTH,
+    height: 540,
+    alwaysOnTop: true,
+    show: false,
+    /** Frameless: no title bar + menu (Windows/macOS). */
+    frame: false,
+    roundedCorners: true,
+    /** Show on taskbar for visibility (COPYHUB_OVERLAY_SKIP_TASKBAR=1 hides from taskbar). */
+    skipTaskbar: process.env.COPYHUB_OVERLAY_SKIP_TASKBAR === '1',
+    title: 'CopyHub',
+    backgroundColor: '#ffffff',
+    webPreferences: {
+      preload: path.join(__dirname, 'preload.cjs'),
+      contextIsolation: true,
+      nodeIntegration: false,
+    },
+  });
+
+  win.loadFile(path.join(__dirname, 'renderer', 'index.html'));
+
+  win.on('show', () => {
+    applyAlwaysOnTopStack(win);
+  });
+
+  if (!STICKY_NO_BLUR) {
+    win.on('blur', () => {
+      if (!blurHideEnabled) return;
+      if (win && !win.webContents.isDevToolsOpened()) {
+        win.hide();
+      }
+    });
+  }
+
+  win.on('close', (e) => {
+    e.preventDefault();
+    win?.hide();
+  });
+
+  win.webContents.on('before-input-event', (_event, input) => {
+    if (input.type === 'keyDown' && input.key === 'Escape') {
+      win?.hide();
+    }
+  });
+
+  win.once('ready-to-show', () => {
+    if (HIDE_ON_START) {
+      blurHideEnabled = true;
+      return;
+    }
+    placeWindowAtCursor(win);
+    win.show();
+    applyAlwaysOnTopStack(win);
+    win.focus();
+    win.webContents.send('overlay:open');
+    setTimeout(() => {
+      applyAlwaysOnTopStack(win);
+      blurHideEnabled = true;
+    }, 800);
+  });
+}
+
+/**
+ * Position window near cursor (display containing pointer).
+ * @param {BrowserWindow} w
+ */
+function placeWindowAtCursor(w) {
+  if (!w || w.isDestroyed()) return;
+  const point = screen.getCursorScreenPoint();
+  const display = screen.getDisplayNearestPoint(point);
+  const { workArea } = display;
+  const { width, height } = w.getBounds();
+  const margin = 10;
+  let x = Math.round(point.x - width / 2);
+  let y = Math.round(point.y - 40);
+  x = Math.max(
+    workArea.x + margin,
+    Math.min(x, workArea.x + workArea.width - width - margin),
+  );
+  y = Math.max(
+    workArea.y + margin,
+    Math.min(y, workArea.y + workArea.height - height - margin),
+  );
+  w.setPosition(x, y);
+}
+
+function toggleOverlay() {
+  if (!win) return;
+  if (win.isVisible()) {
+    win.hide();
+  } else {
+    blurHideEnabled = false;
+    placeWindowAtCursor(win);
+    win.show();
+    applyAlwaysOnTopStack(win);
+    win.focus();
+    win.webContents.send('overlay:open');
+    setTimeout(() => {
+      applyAlwaysOnTopStack(win);
+      blurHideEnabled = true;
+    }, 800);
+  }
+}
+
+/**
+ * Register global shortcut: try .env (normalized) then default CommandOrControl+Shift+H.
+ * @returns {{ accelerator: string, usedFallback: boolean }}
+ */
+function registerHotkeys() {
+  const raw =
+    process.env.COPYHUB_OVERLAY_ACCELERATOR?.trim() ||
+    loadOverlayAcceleratorFromConfigSync();
+  const candidates = [];
+  if (raw) {
+    const n = normalizeAccelerator(raw);
+    if (n) candidates.push(n);
+  }
+  candidates.push(DEFAULT_ACCEL);
+
+  let usedFallback = false;
+  for (let i = 0; i < candidates.length; i++) {
+    const acc = candidates[i];
+    try {
+      if (globalShortcut.register(acc, () => toggleOverlay())) {
+        if (i > 0) usedFallback = true;
+        return { accelerator: acc, usedFallback };
+      }
+    } catch (e) {
+      console.warn('Invalid accelerator:', acc, /** @type {Error} */ (e).message);
+    }
+    try {
+      globalShortcut.unregister(acc);
+    } catch {
+      /* ignore */
+    }
+  }
+  return { accelerator: '', usedFallback: false };
+}
+
+function registerIpc() {
+  ipcMain.handle('overlay:meta', () => ({
+    ...overlayHotkeyMeta,
+    platform: process.platform,
+    defaultAccelerator: DEFAULT_ACCEL,
+    sticky: STICKY_NO_BLUR,
+  }));
+
+  ipcMain.handle('history:get', () => {
+    try {
+      return {
+        items: readRecentHistorySync(200).map((row) => ({
+          ts: row.ts || '',
+          text: typeof row.text === 'string' ? row.text : '',
+          synced: Boolean(row.syncedToSheet || row.syncedToGmail),
+        })),
+      };
+    } catch (e) {
+      return { error: /** @type {Error} */ (e).message, items: [] };
+    }
+  });
+
+  ipcMain.handle('history:copy', (_e, text) => {
+    if (typeof text === 'string') {
+      clipboard.writeText(text);
+    }
+    win?.hide();
+    return true;
+  });
+}
+
+function registerTray() {
+  const icon = nativeImage.createFromDataURL(
+    'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAMUlEQVQ4T2NkYGAQYcAP3uCTZhn1IGOMJoAmBGOSMDEwMmABWDWHJjBCSpBKGBSDjBAAAeoRBIEs/x0AAAAASUVORK5CYII=',
+  );
+  tray = new Tray(icon);
+  tray.setToolTip('CopyHub overlay');
+  const accLabel = overlayHotkeyMeta.accelerator
+    ? `Shortcut: ${overlayHotkeyMeta.accelerator}`
+    : 'Shortcut: (see terminal)';
+  tray.setContextMenu(
+    Menu.buildFromTemplate([
+      { label: accLabel, enabled: false },
+      { label: 'Open history (always on top)', click: () => toggleOverlay() },
+      { type: 'separator' },
+      { label: 'Quit', click: () => app.quit() },
+    ]),
+  );
+  tray.on('click', () => toggleOverlay());
+}
+
+if (gotLock) {
+  app.on('second-instance', () => {
+    toggleOverlay();
+  });
+
+  app.whenReady().then(() => {
+    Menu.setApplicationMenu(null);
+    createWindow();
+    registerIpc();
+
+    const { accelerator, usedFallback } = registerHotkeys();
+    overlayHotkeyMeta = {
+      accelerator,
+      usedFallback,
+      requestedRaw:
+        process.env.COPYHUB_OVERLAY_ACCELERATOR?.trim() ||
+        loadOverlayAcceleratorFromConfigSync() ||
+        '',
+    };
+    if (accelerator) {
+      console.log('CopyHub overlay — shortcut in use:', accelerator);
+      console.log('Windows tip: Ctrl+Shift+H (CommandOrControl+Shift+H).');
+      if (usedFallback) {
+        console.warn(
+          'COPYHUB_OVERLAY_ACCELERATOR could not be registered. Using default CommandOrControl+Shift+H.',
+        );
+        console.warn('Leave COPYHUB_OVERLAY_ACCELERATOR unset in .env to always use Ctrl+Shift+H.');
+      }
+    } else {
+      console.error(
+        'Could not register a global shortcut. Open history from the tray or taskbar icon.',
+      );
+    }
+
+    console.log(
+      STICKY_NO_BLUR
+        ? 'COPYHUB_OVERLAY_STICKY=1 — window does not close on outside click (Esc / row pick only).'
+        : 'Overlay: opens near cursor; click outside the window to close. Esc closes too. COPYHUB_OVERLAY_STICKY=1 keeps it open on blur.',
+    );
+    console.log(
+      HIDE_ON_START
+        ? 'COPYHUB_OVERLAY_HIDE_ON_START=1 — window opens only via shortcut / tray.'
+        : 'Window shows on startup; check taskbar or tray if you do not see it.',
+    );
+
+    try {
+      registerTray();
+    } catch (e) {
+      console.warn('Could not create system tray icon:', /** @type {Error} */ (e).message);
+    }
+  });
+
+  app.on('will-quit', () => {
+    globalShortcut.unregisterAll();
+  });
+}

package/ui/preload.cjs

@@ -0,0 +1,12 @@
+const { contextBridge, ipcRenderer } = require('electron');
+
+contextBridge.exposeInMainWorld('copyhub', {
+  getMeta: () => ipcRenderer.invoke('overlay:meta'),
+  getHistory: () => ipcRenderer.invoke('history:get'),
+  copyPick: (text) => ipcRenderer.invoke('history:copy', text),
+  onOpen: (fn) => {
+    ipcRenderer.on('overlay:open', (_e) => {
+      fn();
+    });
+  },
+});