main.go

/*
Copyright © 2026, Vitalii Tereshchuk | DOTOCA.NET All rights reserved.
Homepage: https://dotoca.net/airdrop

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package main

/*
#cgo LDFLAGS: -L. -lairdrop -framework Cocoa
#include "airdrop.h"
#include <stdlib.h>
*/
import "C"

import (
	"flag"
	"fmt"
	"io"
	"net/http"
	"os"
	"os/signal"
	"path/filepath"
	"runtime"
	"strings"
	"syscall"
	"time"
	"unsafe"
)

var (
	verbose     bool
	showVersion bool
	version     = "0.3.6"
)

var tempFiles []string

func colorize(text, colorCode string) string {
	reset := "\033[0m"
	return colorCode + text + reset
}

func logf(format string, a ...interface{}) {
	if verbose {
		fmt.Fprintf(os.Stderr, format+"\n", a...)
	}
}

func cleanup() {
	for _, f := range tempFiles {
		_ = os.Remove(f)
	}
}

func detectExtFromBytes(sample []byte) string {
	ct := http.DetectContentType(sample)
	switch {
	case strings.HasPrefix(ct, "image/png"):
		return ".png"
	case strings.HasPrefix(ct, "image/jpeg"):
		return ".jpg"
	case strings.HasPrefix(ct, "image/gif"):
		return ".gif"
	case strings.HasPrefix(ct, "application/pdf"):
		return ".pdf"
	case strings.HasPrefix(ct, "text/"):
		return ".txt"
	default:
		return ""
	}
}

func main() {
	runtime.LockOSThread()
	defer runtime.UnlockOSThread()

	flag.BoolVar(&verbose, "v", false, "verbose logging")
	flag.BoolVar(&showVersion, "version", false, "show version information")

	flag.Usage = func() {
		cyan := "\033[36m"
		yellow := "\033[33m"
		bold := "\033[1m"

		year := time.Now().Year()
		fmt.Fprintf(os.Stderr, "%s\n\n", colorize(fmt.Sprintf("Copyright © %d, Vitalii Tereshchuk | All rights reserved | https://dotoca.net/airdrop", year), cyan))
		fmt.Fprintf(os.Stderr, "%s%s%s\n\n", bold, colorize("CLI Utility for Apple AirDrop — version "+version, yellow), "\033[0m")
		fmt.Fprintf(os.Stderr, "%s\n", colorize("Usage:", bold))
		fmt.Fprintf(os.Stderr, "  %s file1 file2 ...\n", os.Args[0])
		fmt.Fprintf(os.Stderr, "  cat file.pdf | %s \n\n", os.Args[0])
		fmt.Fprintf(os.Stderr, "%s\n", colorize("Options:", bold))
		flag.PrintDefaults()
	}

	flag.Parse()

	if showVersion {
		fmt.Println("airdrop version " + version)
		os.Exit(0)
	}

	info, _ := os.Stdin.Stat()
	noArgs := flag.NArg() == 0
	stdinIsPipe := (info.Mode() & os.ModeCharDevice) == 0

	if noArgs && !stdinIsPipe {
		flag.Usage()
		os.Exit(1)
	}

	defer cleanup()

	c := make(chan os.Signal, 1)
	signal.Notify(c, syscall.SIGINT, syscall.SIGTERM)
	go func() {
		s := <-c
		logf("Caught signal %v — cleaning up", s)
		cleanup()
		os.Exit(130)
	}()

	var files []string

	if flag.NArg() > 0 {
		files = append(files, flag.Args()...)
	} else {
		const sniffLen = 512
		buf := make([]byte, sniffLen)
		n, err := io.ReadAtLeast(os.Stdin, buf, 1)
		if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF {
			fmt.Fprintln(os.Stderr, "Failed to read stdin for sniffing:", err)
			os.Exit(2)
		}
		sample := buf[:n]

		ext := detectExtFromBytes(sample)
		tmp, err := os.CreateTemp("", "airdrop_stdin_*"+ext)
		if err != nil {
			fmt.Fprintln(os.Stderr, "Failed to create temp file:", err)
			os.Exit(3)
		}
		tmpName := tmp.Name()
		tempFiles = append(tempFiles, tmpName)

		if _, err = tmp.Write(sample); err != nil {
			_ = tmp.Close()
			fmt.Fprintln(os.Stderr, "Failed to write to temp file:", err)
			os.Exit(4)
		}
		if _, err = io.Copy(tmp, os.Stdin); err != nil {
			_ = tmp.Close()
			fmt.Fprintln(os.Stderr, "Failed to write rest of stdin:", err)
			os.Exit(5)
		}
		if err := tmp.Close(); err != nil {
			fmt.Fprintln(os.Stderr, "Failed to close temp file:", err)
			os.Exit(6)
		}
		files = append(files, tmpName)
		logf("stdin saved to %s (detected ext %s)", tmpName, ext)
	}

	for _, f := range files {
		if _, err := os.Stat(f); err != nil {
			fmt.Fprintln(os.Stderr, "File not accessible:", f, ":", err)
			os.Exit(10)
		}
	}

	cFiles := make([]*C.char, len(files))
	for i, f := range files {
		abs := f
		if !filepath.IsAbs(f) {
			if a, err := filepath.Abs(f); err == nil {
				abs = a
			}
		}
		cFiles[i] = C.CString(abs)
		defer C.free(unsafe.Pointer(cFiles[i]))
		logf("prepared file %d -> %s", i, abs)
	}

	if len(cFiles) == 0 {
		fmt.Fprintln(os.Stderr, "No files to share")
		os.Exit(11)
	}

	ptr := (**C.char)(unsafe.Pointer(&cFiles[0]))
	res := C.ShareViaAirDrop(ptr, C.int(len(cFiles)))
	if res != 0 {
		fmt.Fprintln(os.Stderr, "AirDrop failed with code:", int(res))
		os.Exit(20 + int(res))
	}
	fmt.Println("AirDrop succeeded")
}