1import { spawn } from 'node:child_process';
2import fs from 'node:fs';
3import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
4import os from 'node:os';
5import path from 'node:path';
6import process from 'node:process';
7import { fileURLToPath } from 'node:url';
8import decodeWebp, { init as initWebpDecode } from '@jsquash/webp/decode.js';
9import { Jimp, JimpMime } from 'jimp';
10 
11const SUPPORTED_IMAGE_EXTS = new Set(['.jpg', '.jpeg', '.png', '.gif', '.webp']);
12 
13function printUsage(exitCode = 0): never {
14  console.log(`Copy image or HTML to system clipboard
15 
16Supports:
17  - Image files (jpg, png, gif, webp) - copies as image data
18  - HTML content - copies as rich text for paste
19 
20Usage:
21  # Copy image to clipboard
22  npx -y bun copy-to-clipboard.ts image /path/to/image.jpg
23 
24  # Copy HTML to clipboard
25  npx -y bun copy-to-clipboard.ts html "<p>Hello</p>"
26 
27  # Copy HTML from file
28  npx -y bun copy-to-clipboard.ts html --file /path/to/content.html
29`);
30  process.exit(exitCode);
31}
32 
33function resolvePath(filePath: string): string {
34  return path.isAbsolute(filePath) ? filePath : path.resolve(process.cwd(), filePath);
35}
36 
37function inferImageMimeType(imagePath: string): string {
38  const ext = path.extname(imagePath).toLowerCase();
39  switch (ext) {
40    case '.jpg':
41    case '.jpeg':
42      return 'image/jpeg';
43    case '.png':
44      return 'image/png';
45    case '.gif':
46      return 'image/gif';
47    case '.webp':
48      return 'image/webp';
49    default:
50      return 'application/octet-stream';
51  }
52}
53 
54type RunResult = { stdout: string; stderr: string; exitCode: number };
55 
56async function runCommand(
57  command: string,
58  args: string[],
59  options?: { input?: string | Buffer; allowNonZeroExit?: boolean },
60): Promise<RunResult> {
61  return await new Promise<RunResult>((resolve, reject) => {
62    const child = spawn(command, args, { stdio: ['pipe', 'pipe', 'pipe'] });
63    const stdoutChunks: Buffer[] = [];
64    const stderrChunks: Buffer[] = [];
65 
66    child.stdout.on('data', (chunk) => stdoutChunks.push(Buffer.from(chunk)));
67    child.stderr.on('data', (chunk) => stderrChunks.push(Buffer.from(chunk)));
68    child.on('error', reject);
69    child.on('close', (code) => {
70      resolve({
71        stdout: Buffer.concat(stdoutChunks).toString('utf8'),
72        stderr: Buffer.concat(stderrChunks).toString('utf8'),
73        exitCode: code ?? 0,
74      });
75    });
76 
77    if (options?.input != null) child.stdin.write(options.input);
78    child.stdin.end();
79  }).then((result) => {
80    if (!options?.allowNonZeroExit && result.exitCode !== 0) {
81      const details = result.stderr.trim() || result.stdout.trim();
82      throw new Error(`Command failed (${command}): exit ${result.exitCode}${details ? `\n${details}` : ''}`);
83    }
84    return result;
85  });
86}
87 
88async function commandExists(command: string): Promise<boolean> {
89  if (process.platform === 'win32') {
90    const result = await runCommand('where', [command], { allowNonZeroExit: true });
91    return result.exitCode === 0 && result.stdout.trim().length > 0;
92  }
93  const result = await runCommand('which', [command], { allowNonZeroExit: true });
94  return result.exitCode === 0 && result.stdout.trim().length > 0;
95}
96 
97async function runCommandWithFileStdin(command: string, args: string[], filePath: string): Promise<void> {
98  await new Promise<void>((resolve, reject) => {
99    const child = spawn(command, args, { stdio: ['pipe', 'pipe', 'pipe'] });
100    const stderrChunks: Buffer[] = [];
101    const stdoutChunks: Buffer[] = [];
102 
103    child.stdout.on('data', (chunk) => stdoutChunks.push(Buffer.from(chunk)));
104    child.stderr.on('data', (chunk) => stderrChunks.push(Buffer.from(chunk)));
105    child.on('error', reject);
106    child.on('close', (code) => {
107      const exitCode = code ?? 0;
108      if (exitCode !== 0) {
109        const details = Buffer.concat(stderrChunks).toString('utf8').trim() || Buffer.concat(stdoutChunks).toString('utf8').trim();
110        reject(
111          new Error(`Command failed (${command}): exit ${exitCode}${details ? `\n${details}` : ''}`),
112        );
113        return;
114      }
115      resolve();
116    });
117 
118    fs.createReadStream(filePath).on('error', reject).pipe(child.stdin);
119  });
120}
121 
122async function withTempDir<T>(prefix: string, fn: (tempDir: string) => Promise<T>): Promise<T> {
123  const tempDir = await mkdtemp(path.join(os.tmpdir(), prefix));
124  try {
125    return await fn(tempDir);
126  } finally {
127    await rm(tempDir, { recursive: true, force: true });
128  }
129}
130 
131function getMacSwiftClipboardSource(): string {
132  return `import AppKit
133import Foundation
134 
135func die(_ message: String, _ code: Int32 = 1) -> Never {
136  FileHandle.standardError.write(message.data(using: .utf8)!)
137  exit(code)
138}
139 
140if CommandLine.arguments.count < 3 {
141  die("Usage: clipboard.swift <image|html> <path>\\n")
142}
143 
144let mode = CommandLine.arguments[1]
145let inputPath = CommandLine.arguments[2]
146let pasteboard = NSPasteboard.general
147pasteboard.clearContents()
148 
149switch mode {
150case "image":
151  guard let image = NSImage(contentsOfFile: inputPath) else {
152    die("Failed to load image: \\(inputPath)\\n")
153  }
154  if !pasteboard.writeObjects([image]) {
155    die("Failed to write image to clipboard\\n")
156  }
157 
158case "html":
159  let url = URL(fileURLWithPath: inputPath)
160  let data: Data
161  do {
162    data = try Data(contentsOf: url)
163  } catch {
164    die("Failed to read HTML file: \\(inputPath)\\n")
165  }
166 
167  _ = pasteboard.setData(data, forType: .html)
168 
169  let options: [NSAttributedString.DocumentReadingOptionKey: Any] = [
170    .documentType: NSAttributedString.DocumentType.html,
171    .characterEncoding: String.Encoding.utf8.rawValue
172  ]
173 
174  if let attr = try? NSAttributedString(data: data, options: options, documentAttributes: nil) {
175    pasteboard.setString(attr.string, forType: .string)
176    if let rtf = try? attr.data(
177      from: NSRange(location: 0, length: attr.length),
178      documentAttributes: [.documentType: NSAttributedString.DocumentType.rtf]
179    ) {
180      _ = pasteboard.setData(rtf, forType: .rtf)
181    }
182  } else if let html = String(data: data, encoding: .utf8) {
183    pasteboard.setString(html, forType: .string)
184  }
185 
186default:
187  die("Unknown mode: \\(mode)\\n")
188}
189`;
190}
191 
192function escapeAppleScriptString(value: string): string {
193  return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
194}
195 
196function getAppleScriptImageType(imagePath: string): string {
197  const ext = path.extname(imagePath).toLowerCase();
198  switch (ext) {
199    case '.png':
200      return '«class PNGf»';
201    case '.jpg':
202    case '.jpeg':
203      return 'JPEG picture';
204    case '.gif':
205      return 'GIF picture';
206    default:
207      throw new Error(`macOS clipboard image copy supports PNG, JPEG, and GIF via AppleScript; convert ${ext || 'this file'} to PNG first.`);
208  }
209}
210 
211let webpDecoderReady: Promise<void> | undefined;
212 
213async function ensureWebpDecoder(): Promise<void> {
214  if (!webpDecoderReady) {
215    webpDecoderReady = (async () => {
216      const __filename = fileURLToPath(import.meta.url);
217      const __dirname = path.dirname(__filename);
218      const wasmPath = path.resolve(__dirname, 'node_modules/@jsquash/webp/codec/dec/webp_dec.wasm');
219      const wasmModule = await WebAssembly.compile(await readFile(wasmPath));
220      await initWebpDecode(wasmModule, {});
221    })();
222  }
223 
224  await webpDecoderReady;
225}
226 
227async function convertWebpMacToPng(webpPath: string, tempDir: string): Promise<string> {
228  await ensureWebpDecoder();
229  const decoded = await decodeWebp(await readFile(webpPath));
230  const image = new Jimp({
231    data: Buffer.from(decoded.data.buffer, decoded.data.byteOffset, decoded.data.byteLength),
232    width: decoded.width,
233    height: decoded.height,
234  });
235  const pngPath = path.join(tempDir, `${path.basename(webpPath, path.extname(webpPath))}.png`);
236  await writeFile(pngPath, await image.getBuffer(JimpMime.png));
237  return pngPath;
238}
239 
240async function copyImageMacWithOsascript(imagePath: string): Promise<void> {
241  const imageType = getAppleScriptImageType(imagePath);
242  const escapedPath = escapeAppleScriptString(imagePath);
243  await runCommand('osascript', [
244    '-e',
245    `set the clipboard to (read (POSIX file "${escapedPath}") as ${imageType})`,
246  ]);
247}
248 
249async function copyImageMac(imagePath: string): Promise<void> {
250  if (path.extname(imagePath).toLowerCase() === '.webp') {
251    await withTempDir('copy-to-clipboard-', async (tempDir) => {
252      const pngPath = await convertWebpMacToPng(imagePath, tempDir);
253      await copyImageMacWithOsascript(pngPath);
254    });
255    return;
256  }
257 
258  await copyImageMacWithOsascript(imagePath);
259}
260 
261async function copyHtmlMac(htmlFilePath: string): Promise<void> {
262  await withTempDir('copy-to-clipboard-', async (tempDir) => {
263    const swiftPath = path.join(tempDir, 'clipboard.swift');
264    await writeFile(swiftPath, getMacSwiftClipboardSource(), 'utf8');
265    await runCommand('swift', [swiftPath, 'html', htmlFilePath]);
266  });
267}
268 
269async function copyImageLinux(imagePath: string): Promise<void> {
270  const mime = inferImageMimeType(imagePath);
271  if (await commandExists('wl-copy')) {
272    await runCommandWithFileStdin('wl-copy', ['--type', mime], imagePath);
273    return;
274  }
275  if (await commandExists('xclip')) {
276    await runCommand('xclip', ['-selection', 'clipboard', '-t', mime, '-i', imagePath]);
277    return;
278  }
279  throw new Error('No clipboard tool found. Install `wl-clipboard` (wl-copy) or `xclip`.');
280}
281 
282async function copyHtmlLinux(htmlFilePath: string): Promise<void> {
283  if (await commandExists('wl-copy')) {
284    await runCommandWithFileStdin('wl-copy', ['--type', 'text/html'], htmlFilePath);
285    return;
286  }
287  if (await commandExists('xclip')) {
288    await runCommand('xclip', ['-selection', 'clipboard', '-t', 'text/html', '-i', htmlFilePath]);
289    return;
290  }
291  throw new Error('No clipboard tool found. Install `wl-clipboard` (wl-copy) or `xclip`.');
292}
293 
294async function copyImageWindows(imagePath: string): Promise<void> {
295  const escaped = imagePath.replace(/'/g, "''");
296  const ps = [
297    'Add-Type -AssemblyName System.Windows.Forms',
298    'Add-Type -AssemblyName System.Drawing',
299    `$img = [System.Drawing.Image]::FromFile('${escaped}')`,
300    '[System.Windows.Forms.Clipboard]::SetImage($img)',
301    '$img.Dispose()',
302  ].join('; ');
303  await runCommand('powershell.exe', ['-NoProfile', '-Sta', '-Command', ps]);
304}
305 
306async function copyHtmlWindows(htmlFilePath: string): Promise<void> {
307  const escaped = htmlFilePath.replace(/'/g, "''");
308  const ps = [
309    'Add-Type -AssemblyName System.Windows.Forms',
310    `$html = Get-Content -Raw -LiteralPath '${escaped}'`,
311    '[System.Windows.Forms.Clipboard]::SetText($html, [System.Windows.Forms.TextDataFormat]::Html)',
312  ].join('; ');
313  await runCommand('powershell.exe', ['-NoProfile', '-Sta', '-Command', ps]);
314}
315 
316async function copyImageToClipboard(imagePathInput: string): Promise<void> {
317  const imagePath = resolvePath(imagePathInput);
318  const ext = path.extname(imagePath).toLowerCase();
319  if (!SUPPORTED_IMAGE_EXTS.has(ext)) {
320    throw new Error(
321      `Unsupported image type: ${ext || '(none)'} (supported: ${Array.from(SUPPORTED_IMAGE_EXTS).join(', ')})`,
322    );
323  }
324  if (!fs.existsSync(imagePath)) throw new Error(`File not found: ${imagePath}`);
325 
326  switch (process.platform) {
327    case 'darwin':
328      await copyImageMac(imagePath);
329      return;
330    case 'linux':
331      await copyImageLinux(imagePath);
332      return;
333    case 'win32':
334      await copyImageWindows(imagePath);
335      return;
336    default:
337      throw new Error(`Unsupported platform: ${process.platform}`);
338  }
339}
340 
341async function copyHtmlFileToClipboard(htmlFilePathInput: string): Promise<void> {
342  const htmlFilePath = resolvePath(htmlFilePathInput);
343  if (!fs.existsSync(htmlFilePath)) throw new Error(`File not found: ${htmlFilePath}`);
344 
345  switch (process.platform) {
346    case 'darwin':
347      await copyHtmlMac(htmlFilePath);
348      return;
349    case 'linux':
350      await copyHtmlLinux(htmlFilePath);
351      return;
352    case 'win32':
353      await copyHtmlWindows(htmlFilePath);
354      return;
355    default:
356      throw new Error(`Unsupported platform: ${process.platform}`);
357  }
358}
359 
360async function readStdinText(): Promise<string | null> {
361  if (process.stdin.isTTY) return null;
362  const chunks: Buffer[] = [];
363  for await (const chunk of process.stdin) {
364    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
365  }
366  const text = Buffer.concat(chunks).toString('utf8');
367  return text.length > 0 ? text : null;
368}
369 
370async function copyHtmlToClipboard(args: string[]): Promise<void> {
371  let htmlFile: string | undefined;
372  const positional: string[] = [];
373 
374  for (let i = 0; i < args.length; i += 1) {
375    const arg = args[i] ?? '';
376    if (arg === '--help' || arg === '-h') printUsage(0);
377    if (arg === '--file') {
378      htmlFile = args[i + 1];
379      i += 1;
380      continue;
381    }
382    if (arg.startsWith('--file=')) {
383      htmlFile = arg.slice('--file='.length);
384      continue;
385    }
386    if (arg === '--') {
387      positional.push(...args.slice(i + 1));
388      break;
389    }
390    if (arg.startsWith('-')) {
391      throw new Error(`Unknown option: ${arg}`);
392    }
393    positional.push(arg);
394  }
395 
396  if (htmlFile && positional.length > 0) {
397    throw new Error('Do not pass HTML text when using --file.');
398  }
399 
400  if (htmlFile) {
401    await copyHtmlFileToClipboard(htmlFile);
402    return;
403  }
404 
405  const htmlFromArgs = positional.join(' ').trim();
406  const htmlFromStdin = (await readStdinText())?.trim() ?? '';
407  const html = htmlFromArgs || htmlFromStdin;
408  if (!html) throw new Error('Missing HTML input. Provide a string or use --file.');
409 
410  await withTempDir('copy-to-clipboard-', async (tempDir) => {
411    const htmlPath = path.join(tempDir, 'input.html');
412    await writeFile(htmlPath, html, 'utf8');
413    await copyHtmlFileToClipboard(htmlPath);
414  });
415}
416 
417async function main(): Promise<void> {
418  const argv = process.argv.slice(2);
419  if (argv.length === 0) printUsage(1);
420 
421  const command = argv[0];
422  if (command === '--help' || command === '-h') printUsage(0);
423 
424  if (command === 'image') {
425    const imagePath = argv[1];
426    if (!imagePath) throw new Error('Missing image path.');
427    await copyImageToClipboard(imagePath);
428    return;
429  }
430 
431  if (command === 'html') {
432    await copyHtmlToClipboard(argv.slice(1));
433    return;
434  }
435 
436  throw new Error(`Unknown command: ${command}`);
437}
438 
439await main().catch((err) => {
440  const message = err instanceof Error ? err.message : String(err);
441  console.error(`Error: ${message}`);
442  process.exit(1);
443});
444