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