shotmon-cli 1.0.0

package/README.md

@@ -0,0 +1,35 @@
+# shotmon
+
+Screenshot monitor CLI. Watches clipboard for screenshots and uploads to remote server via SSH, or saves locally.
+
+## Install
+
+```bash
+npm install -g shotmon
+```
+
+## Commands
+
+```
+shotmon              Setup config and start monitoring
+shotmon start        Start monitoring (select target)
+shotmon stop         Stop monitoring
+shotmon status       Show running status and target
+shotmon config       Modify remotes configuration
+shotmon uninstall    Remove config files
+```
+
+## Features
+
+- Auto-detects SSH remotes from `~/.ssh/config` and shell history
+- **Local mode**: Saves to `~/shotmon-screenshots/`, copies path to clipboard
+- **Remote mode**: Uploads via SSH, copies remote path to clipboard
+- Fast SSH with ControlMaster connection reuse
+- WSL support (reads Windows clipboard)
+
+## How it works
+
+1. Polls clipboard for new images (200ms interval)
+2. Detects changes via MD5 hash comparison
+3. Uploads via SSH or saves locally
+4. Copies absolute path to clipboard for easy pasting

package/dist/config.js

@@ -0,0 +1,136 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigPath = getConfigPath;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.detectSSHRemotes = detectSSHRemotes;
+exports.detectSSHFromHistory = detectSSHFromHistory;
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function getConfigPath() {
+    return path.join(os.homedir(), ".config", "shotmon", "config.json");
+}
+function loadConfig() {
+    const configPath = getConfigPath();
+    if (!fs.existsSync(configPath)) {
+        return null;
+    }
+    const content = fs.readFileSync(configPath, "utf-8");
+    return JSON.parse(content);
+}
+function saveConfig(config) {
+    const configPath = getConfigPath();
+    const configDir = path.dirname(configPath);
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+function detectSSHRemotes() {
+    const home = os.homedir();
+    const sshConfigPath = path.join(home, ".ssh", "config");
+    if (!fs.existsSync(sshConfigPath)) {
+        return [];
+    }
+    const content = fs.readFileSync(sshConfigPath, "utf-8");
+    const lines = content.split("\n");
+    const hosts = [];
+    let currentHost = null;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.toLowerCase().startsWith("host ")) {
+            if (currentHost) {
+                hosts.push(currentHost);
+            }
+            const hostName = trimmed.slice(5).trim().split(/\s+/)[0];
+            // Skip wildcard patterns
+            if (!hostName.includes("*")) {
+                currentHost = { name: hostName };
+            }
+            else {
+                currentHost = null;
+            }
+        }
+        else if (currentHost) {
+            if (trimmed.toLowerCase().startsWith("hostname ")) {
+                currentHost.hostname = trimmed.slice(9).trim();
+            }
+            else if (trimmed.toLowerCase().startsWith("user ")) {
+                currentHost.user = trimmed.slice(5).trim();
+            }
+        }
+    }
+    if (currentHost) {
+        hosts.push(currentHost);
+    }
+    return hosts;
+}
+function detectSSHFromHistory() {
+    const home = os.homedir();
+    const historyFiles = [
+        path.join(home, ".bash_history"),
+        path.join(home, ".zsh_history"),
+    ];
+    const remotes = new Set();
+    for (const histFile of historyFiles) {
+        if (!fs.existsSync(histFile))
+            continue;
+        try {
+            const content = fs.readFileSync(histFile, "utf-8");
+            const lines = content.split("\n");
+            for (const line of lines) {
+                // Match ssh commands: ssh [options] user@host or ssh [options] host
+                const match = line.match(/\bssh\s+(?:[^@\s]+\s+)*?(\S+@\S+?)(?:\s|$)/);
+                if (match) {
+                    const remote = match[1];
+                    // Filter out flags and invalid entries
+                    if (remote.includes("@") && !remote.startsWith("-")) {
+                        // Clean up any trailing characters
+                        const clean = remote.replace(/[;|&].*$/, "");
+                        if (clean.match(/^[\w.-]+@[\w.-]+$/)) {
+                            remotes.add(clean);
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore read errors
+        }
+    }
+    return Array.from(remotes);
+}

package/dist/index.js

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const config_1 = require("./config");
+const prompts_1 = require("./prompts");
+const monitor_1 = require("./monitor");
+function getVersion() {
+    const pkgPath = path.join(__dirname, "..", "package.json");
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    return pkg.version;
+}
+async function addRemotes(existing) {
+    const remotes = [...existing];
+    // Collect all detected remotes
+    const allDetected = [];
+    // From SSH config
+    const sshHosts = (0, config_1.detectSSHRemotes)();
+    for (const host of sshHosts) {
+        if (!remotes.includes(host.name)) {
+            const details = [host.user, host.hostname].filter(Boolean).join("@");
+            allDetected.push({
+                name: host.name,
+                source: details ? `config: ${details}` : "config",
+            });
+        }
+    }
+    // From bash/zsh history
+    const historyRemotes = (0, config_1.detectSSHFromHistory)();
+    for (const remote of historyRemotes) {
+        if (!remotes.includes(remote) && !allDetected.find(d => d.name === remote)) {
+            allDetected.push({
+                name: remote,
+                source: "history",
+            });
+        }
+    }
+    if (allDetected.length > 0) {
+        const choices = allDetected.map(d => `${d.name} (${d.source})`);
+        const selected = await (0, prompts_1.promptMultiSelect)("Select SSH remotes to add (space to toggle, enter to confirm)", choices);
+        for (const msg of selected) {
+            const detected = allDetected.find(d => `${d.name} (${d.source})` === msg);
+            if (detected) {
+                remotes.push(detected.name);
+            }
+        }
+    }
+    // Add custom remotes
+    let addMore = await (0, prompts_1.promptConfirm)("Add a custom SSH remote?");
+    while (addMore) {
+        const remoteName = await (0, prompts_1.promptInput)("Enter SSH remote (e.g., user@host)");
+        if (remoteName && !remotes.includes(remoteName)) {
+            remotes.push(remoteName);
+            console.log(`Added: ${remoteName}`);
+        }
+        addMore = await (0, prompts_1.promptConfirm)("Add another?");
+    }
+    return remotes;
+}
+function startBackground(remote) {
+    const child = (0, child_process_1.spawn)(process.execPath, [__filename, "--daemon", remote], {
+        detached: true,
+        stdio: "ignore",
+        env: { ...process.env, SHOTMON_BACKGROUND: "1" },
+    });
+    child.unref();
+    console.log(`Started in background (PID: ${child.pid})`);
+    console.log(`Logs: ~/.config/shotmon/logs/`);
+}
+function showHelp() {
+    console.log(`Usage: shotmon <command>
+
+Commands:
+  start      Start monitoring in background
+  stop       Stop background process
+  status     Show if running
+  config     Modify configuration
+  uninstall  Remove config and stop process
+
+Run without command to setup/configure.
+`);
+}
+function uninstall() {
+    // Stop any running process
+    try {
+        const result = (0, child_process_1.execSync)("pgrep -f 'node.*[s]hotmon.*--daemon'", { encoding: "utf8" });
+        const pids = result.trim().split("\n").filter(Boolean);
+        for (const pid of pids) {
+            process.kill(parseInt(pid), "SIGTERM");
+        }
+        if (pids.length > 0) {
+            console.log("Stopped running process");
+        }
+    }
+    catch {
+        // Not running
+    }
+    // Remove config directory
+    const configDir = path.join(os.homedir(), ".config", "shotmon");
+    if (fs.existsSync(configDir)) {
+        fs.rmSync(configDir, { recursive: true });
+        console.log(`Removed ${configDir}`);
+    }
+    console.log("\nNow run: npm uninstall -g shotmon");
+}
+function stopBackground() {
+    try {
+        // Use bracket trick to avoid pgrep matching itself
+        const result = (0, child_process_1.execSync)("pgrep -f 'node.*[s]hotmon.*--daemon'", { encoding: "utf8" });
+        const pids = result.trim().split("\n").filter(Boolean);
+        for (const pid of pids) {
+            process.kill(parseInt(pid), "SIGTERM");
+            console.log(`Stopped process ${pid}`);
+        }
+        if (pids.length === 0) {
+            console.log("No shotmon process running");
+        }
+    }
+    catch {
+        console.log("No shotmon process running");
+    }
+}
+function showStatus() {
+    try {
+        // Use bracket trick to avoid pgrep matching itself
+        const result = (0, child_process_1.execSync)("pgrep -af 'node.*[s]hotmon.*--daemon'", { encoding: "utf8" });
+        const lines = result.trim().split("\n").filter(Boolean);
+        if (lines.length > 0) {
+            for (const line of lines) {
+                // Parse "PID command args"
+                const match = line.match(/^(\d+)\s+.*--daemon\s+(.+)$/);
+                if (match) {
+                    const pid = match[1];
+                    const target = match[2];
+                    console.log(`Running (PID: ${pid}) -> ${target}`);
+                }
+                else {
+                    const pid = line.split(/\s+/)[0];
+                    console.log(`Running (PID: ${pid})`);
+                }
+            }
+        }
+        else {
+            console.log("Not running");
+        }
+    }
+    catch {
+        console.log("Not running");
+    }
+}
+async function runConfig() {
+    let config = (0, config_1.loadConfig)();
+    if (!config || config.remotes.length === 0) {
+        if (!config) {
+            console.log("Welcome! Let's add some SSH remotes.\n");
+        }
+        else {
+            console.log("No remotes configured. Let's add some.\n");
+        }
+        const remotes = await addRemotes([]);
+        config = { remotes };
+        (0, config_1.saveConfig)(config);
+        if (remotes.length > 0) {
+            console.log(`\nSaved ${remotes.length} remote(s).`);
+        }
+    }
+    else {
+        console.log(`SSH remotes: ${config.remotes.join(", ")}\n`);
+        const modify = await (0, prompts_1.promptConfirm)("Modify remotes?");
+        if (modify) {
+            const toKeep = await (0, prompts_1.promptMultiSelect)("Select remotes to keep (space to toggle, enter to confirm)", config.remotes);
+            const remotes = await addRemotes(toKeep);
+            config = { remotes };
+            (0, config_1.saveConfig)(config);
+            console.log(`\nSaved ${remotes.length} remote(s).`);
+        }
+    }
+    return config;
+}
+async function startCommand() {
+    const config = (0, config_1.loadConfig)();
+    if (!config || config.remotes.length === 0) {
+        console.log("No remotes configured. Run 'shotmon' first to set up.");
+        process.exit(1);
+    }
+    // Add "local" option to the list
+    const options = ["local", ...config.remotes];
+    let selected;
+    if (options.length === 1) {
+        selected = options[0];
+    }
+    else {
+        selected = await (0, prompts_1.promptSelect)("Select target", options);
+    }
+    // Stop any existing process before starting new one
+    try {
+        const result = (0, child_process_1.execSync)("pgrep -f 'node.*[s]hotmon.*--daemon'", { encoding: "utf8" });
+        const pids = result.trim().split("\n").filter(Boolean);
+        for (const pid of pids) {
+            process.kill(parseInt(pid), "SIGTERM");
+        }
+        if (pids.length > 0) {
+            console.log(`Stopped previous process`);
+        }
+    }
+    catch {
+        // Not running, continue
+    }
+    startBackground(selected);
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    // Handle --daemon (internal use)
+    if (command === "--daemon") {
+        const remote = args[1];
+        if (remote) {
+            await (0, monitor_1.startMonitor)(remote);
+        }
+        return;
+    }
+    console.log(`shotmon v${getVersion()}\n`);
+    // Handle commands
+    if (command === "help" || command === "--help" || command === "-h") {
+        showHelp();
+        return;
+    }
+    if (command === "stop") {
+        stopBackground();
+        return;
+    }
+    if (command === "status") {
+        showStatus();
+        return;
+    }
+    if (command === "start") {
+        await startCommand();
+        return;
+    }
+    if (command === "config") {
+        await runConfig();
+        return;
+    }
+    if (command === "uninstall") {
+        uninstall();
+        return;
+    }
+    // No command - run config flow then auto-start
+    const config = await runConfig();
+    if (config.remotes.length === 0) {
+        console.log("No remotes configured. Run shotmon again to add remotes.");
+        process.exit(0);
+    }
+    console.log("\n--- Starting monitor ---\n");
+    await startCommand();
+}
+main().catch(console.error);

package/dist/monitor.js

@@ -0,0 +1,283 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startMonitor = startMonitor;
+const child_process_1 = require("child_process");
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const POLL_INTERVAL_MS = 200;
+const LOG_MAX_AGE_MS = 60 * 60 * 1000; // 1 hour
+let lastImageHash = null;
+let logFile = null;
+let logStartTime = 0;
+function isWSL() {
+    try {
+        const release = fs.readFileSync("/proc/version", "utf8");
+        return release.toLowerCase().includes("microsoft") || release.toLowerCase().includes("wsl");
+    }
+    catch {
+        return false;
+    }
+}
+function getLogDir() {
+    return path.join(os.homedir(), ".config", "shotmon", "logs");
+}
+function ensureLogDir() {
+    const logDir = getLogDir();
+    if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+    }
+}
+function createNewLogFile() {
+    ensureLogDir();
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const filename = `shotmon-${timestamp}.log`;
+    return path.join(getLogDir(), filename);
+}
+function log(message) {
+    const now = Date.now();
+    const timestamp = new Date().toISOString();
+    const line = `[${timestamp}] ${message}\n`;
+    // Check if we need a new log file
+    if (!logFile || (now - logStartTime) > LOG_MAX_AGE_MS) {
+        logFile = createNewLogFile();
+        logStartTime = now;
+    }
+    // Write to file
+    fs.appendFileSync(logFile, line);
+    // Also print to console if not in background
+    if (!process.env.SHOTMON_BACKGROUND) {
+        process.stdout.write(message + "\n");
+    }
+}
+async function getClipboardImageWSL() {
+    try {
+        // PowerShell script to get clipboard image as base64
+        const psScript = `
+Add-Type -AssemblyName System.Windows.Forms
+$img = [System.Windows.Forms.Clipboard]::GetImage()
+if ($img -ne $null) {
+  $ms = New-Object System.IO.MemoryStream
+  $img.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png)
+  [Convert]::ToBase64String($ms.ToArray())
+}
+`;
+        // Encode as UTF-16LE base64 for -EncodedCommand
+        const encoded = Buffer.from(psScript, "utf16le").toString("base64");
+        const result = (0, child_process_1.execSync)(`powershell.exe -NoProfile -EncodedCommand ${encoded}`, {
+            encoding: "utf8",
+            timeout: 5000,
+        }).trim();
+        if (result && result.length > 0) {
+            return Buffer.from(result, "base64");
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+async function getClipboardImageNative() {
+    try {
+        // Try using @crosscopy/clipboard for native Linux/macOS
+        // @ts-ignore
+        const Clipboard = require("@crosscopy/clipboard").default;
+        const hasImage = await Clipboard.hasImage();
+        if (!hasImage) {
+            return null;
+        }
+        const base64 = await Clipboard.getImageBase64();
+        if (!base64) {
+            return null;
+        }
+        return Buffer.from(base64, "base64");
+    }
+    catch {
+        return null;
+    }
+}
+async function getClipboardImage() {
+    if (isWSL()) {
+        return getClipboardImageWSL();
+    }
+    return getClipboardImageNative();
+}
+function getImageHash(buffer) {
+    return crypto.createHash("md5").update(buffer).digest("hex");
+}
+function generateFilename() {
+    const now = new Date();
+    const timestamp = now.toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    return `screenshot-${timestamp}.png`;
+}
+function getLocalScreenshotDir() {
+    return path.join(os.homedir(), "shotmon-screenshots");
+}
+function saveLocal(imageBuffer, filename) {
+    const dir = getLocalScreenshotDir();
+    const filePath = path.join(dir, filename);
+    try {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(filePath, imageBuffer);
+        return { success: true, path: filePath };
+    }
+    catch {
+        return { success: false, path: filePath };
+    }
+}
+function getRemoteHomeDir(remote) {
+    // Extract username from user@host format
+    const match = remote.match(/^([^@]+)@/);
+    const user = match ? match[1] : "root";
+    return user === "root" ? "/root" : `/home/${user}`;
+}
+async function pipeToRemote(imageBuffer, remote, filename) {
+    const homeDir = getRemoteHomeDir(remote);
+    const remotePath = `${homeDir}/shotmon-screenshots/${filename}`;
+    return new Promise((resolve) => {
+        // Ensure directory exists and write file
+        // Use ControlMaster options for faster repeated connections
+        const proc = (0, child_process_1.spawn)("ssh", [
+            "-o", "ControlMaster=auto",
+            "-o", "ControlPath=~/.ssh/shotmon-%r@%h:%p",
+            "-o", "ControlPersist=60",
+            remote,
+            `mkdir -p ${homeDir}/shotmon-screenshots && cat > ${remotePath}`
+        ]);
+        proc.stdin.write(imageBuffer);
+        proc.stdin.end();
+        proc.on("close", (code) => {
+            resolve({ success: code === 0, path: remotePath });
+        });
+        proc.on("error", () => {
+            resolve({ success: false, path: remotePath });
+        });
+    });
+}
+function copyToClipboardWSL(text) {
+    try {
+        // Use clip.exe which is much faster than PowerShell
+        (0, child_process_1.execSync)(`echo -n '${text.replace(/'/g, "'\\''")}' | clip.exe`, { timeout: 2000 });
+    }
+    catch {
+        // Ignore clipboard errors
+    }
+}
+async function copyToClipboardNative(text) {
+    try {
+        // @ts-ignore
+        const Clipboard = require("@crosscopy/clipboard").default;
+        await Clipboard.setText(text);
+    }
+    catch {
+        // Ignore clipboard errors
+    }
+}
+async function copyToClipboard(text) {
+    if (isWSL()) {
+        copyToClipboardWSL(text);
+    }
+    else {
+        await copyToClipboardNative(text);
+    }
+}
+async function startMonitor(remote) {
+    // Initialize logging
+    logFile = createNewLogFile();
+    logStartTime = Date.now();
+    const wsl = isWSL();
+    log(`Starting monitor for: ${remote}`);
+    log(`Environment: ${wsl ? "WSL" : "Native"}`);
+    log(`Log file: ${logFile}`);
+    if (remote === "local") {
+        log(`Saving to: ${getLocalScreenshotDir()}`);
+    }
+    log("");
+    log("Monitoring clipboard... (Ctrl+C to stop)");
+    log("");
+    // Initialize with current clipboard state
+    const initialImage = await getClipboardImage();
+    if (initialImage) {
+        lastImageHash = getImageHash(initialImage);
+    }
+    const poll = async () => {
+        try {
+            const imageBuffer = await getClipboardImage();
+            if (!imageBuffer) {
+                return;
+            }
+            const currentHash = getImageHash(imageBuffer);
+            if (currentHash !== lastImageHash) {
+                lastImageHash = currentHash;
+                const filename = generateFilename();
+                const size = Math.round(imageBuffer.length / 1024);
+                log(`New screenshot: ${filename} (${size}KB)`);
+                if (remote === "local") {
+                    const result = saveLocal(imageBuffer, filename);
+                    if (result.success) {
+                        log(`  -> Saved: ${result.path}`);
+                        await copyToClipboard(result.path);
+                        log(`  -> Copied to clipboard`);
+                    }
+                    else {
+                        log(`  -> Failed to save locally`);
+                    }
+                }
+                else {
+                    const result = await pipeToRemote(imageBuffer, remote, filename);
+                    if (result.success) {
+                        log(`  -> Sent to ${remote}:${result.path}`);
+                        await copyToClipboard(result.path);
+                        log(`  -> Copied to clipboard`);
+                    }
+                    else {
+                        log(`  -> Failed to send to ${remote}`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            log(`Error: ${err}`);
+        }
+    };
+    // Start polling
+    setInterval(poll, POLL_INTERVAL_MS);
+    // Keep process running
+    await new Promise(() => { });
+}

package/dist/prompts.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptConfirm = promptConfirm;
+exports.promptInput = promptInput;
+exports.promptSelect = promptSelect;
+exports.promptMultiSelect = promptMultiSelect;
+// @ts-ignore
+const { Select, Confirm, Input, MultiSelect } = require("enquirer");
+async function promptConfirm(message) {
+    const prompt = new Confirm({ name: "confirm", message });
+    return prompt.run();
+}
+async function promptInput(message) {
+    const prompt = new Input({ name: "input", message });
+    return prompt.run();
+}
+async function promptSelect(message, choices) {
+    const prompt = new Select({ name: "select", message, choices });
+    return prompt.run();
+}
+async function promptMultiSelect(message, choices) {
+    const prompt = new MultiSelect({
+        name: "multiselect",
+        message,
+        choices: choices,
+        initial: choices,
+        hint: "(space to toggle, enter to confirm)",
+        indicator(state, choice) {
+            return choice.enabled ? "●" : "○";
+        },
+    });
+    return prompt.run();
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "shotmon-cli",
+  "version": "1.0.0",
+  "description": "Screenshot monitor CLI tool",
+  "main": "dist/index.js",
+  "bin": {
+    "shotmon": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "screenshot",
+    "monitor",
+    "clipboard"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^25.0.10",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@crosscopy/clipboard": "^0.2.8",
+    "enquirer": "^2.4.1"
+  }
+}