PicoShare

PicoShare is a minimalist, self‑hosted file transfer service that exposes a single‑page web UI for uploading and sharing arbitrary files. From a developer’s standpoint, it is essentially a thin HTTP server that accepts multipart uploads, persists the file metadata to an embedded SQLite database, and serves the files directly from disk or a cloud‑backed storage bucket. The service guarantees direct download links without any transformation, so the original file’s MIME type, size, and metadata are preserved exactly as uploaded. This makes it a perfect fit for internal tooling, CI/CD artifact sharing, or any scenario where you need a lightweight “drop‑box” that can be spun up in minutes.

• Language & Runtime: Go (1.20+), leveraging the standard library’s net/http for request handling and mime/multipart for uploads. The binary is statically linked, simplifying deployment to any Linux container or bare metal host.
• Data Layer: A single SQLite database stores file records (ID, original filename, MIME type, size, upload timestamp). The database is accessed via the database/sql package with a lightweight driver (modernc.org/sqlite). For high‑availability or persistence across restarts, PicoShare can be paired with Litestream, which streams SQLite changes to an S3‑compatible bucket.
• Storage: Files are written to a local directory (/data by default). When Litestream is configured, the same directory is mirrored to cloud storage; otherwise, it remains purely on‑disk.
• Web UI: A minimal HTML/JS front end (bundled with the binary) provides drag‑and‑drop and single‑click upload. No external assets or CDNs are required, keeping the footprint small.
• Containerization: A Docker image is provided on Docker Hub. The container expects environment variables for PORT, PS_SHARED_SECRET (used to sign URLs), and optional Litestream credentials. The image mounts a host volume for /data, ensuring persistence outside the container.

• Upload Endpoint (POST /upload): Accepts multipart form data. Returns a JSON payload containing the unique download URL, filename, size, and MIME type.
• Download Endpoint (GET /{id}): Serves the file with Content-Disposition: attachment to force download. The URL can be signed with a shared secret (PS_SHARED_SECRET) to prevent enumeration.
• Metadata API: The upload response includes all metadata; no separate endpoint is needed. However, developers can query the SQLite database directly if they need bulk access.
• Configuration: All operational parameters are exposed via environment variables—no configuration files. This aligns with twelve‑factor app principles and simplifies orchestration in Kubernetes or Docker Swarm.
• Extensibility Hooks: While PicoShare itself has no plugin system, its lightweight codebase and exposed HTTP endpoints make it trivial to wrap with additional middleware (e.g., authentication, rate limiting) or integrate into existing API gateways.

• Self‑Hosting: A single binary or Docker container is all that’s required. No external services are needed unless you opt for Litestream replication.
• Scalability: The stateless nature of the HTTP server allows horizontal scaling behind a load balancer. Each instance can point to the same Litestream‑backed storage bucket, ensuring consistency across replicas.
• High Availability: Pairing with Litestream gives near‑real‑time data replication. Because SQLite is file‑based, you can run multiple replicas that share the same database file via a network filesystem (e.g., NFS) if you prefer local persistence.
• Resource Footprint: The Go binary is ~10 MB, and the database plus uploaded files are stored on disk. Memory usage stays below 50 MiB for typical workloads, making it suitable for low‑cost VPS or edge devices.

• Webhooks: Developers can poll the SQLite database or wrap the upload handler to emit events (e.g., via a message queue) whenever a new file is added.
• Authentication: While PicoShare itself has no built‑in auth, the PS_SHARED_SECRET can be used to sign URLs. For stricter access control, mount PicoShare behind an OAuth or API‑key gateway.
• Custom UI: The front‑end is a single HTML file; you can fork it or replace it entirely with your own UI that talks to the same endpoints.
• CLI Clients: Since uploads are standard multipart POSTs, any HTTP client (curl, wget, or language SDK) can interact programmatically. This makes PicoShare a drop‑in artifact store for CI pipelines.

• Documentation: The README covers all key concepts, environment variables, and deployment scenarios. Inline comments in the source provide additional context.
• Community & Licensing: Licensed under AGPLv3, PicoShare benefits from a permissive open‑source model that encourages commercial use while ensuring improvements are shared. The repository has an active contributor base and regular CI checks.
• Testing: The codebase includes unit tests for the upload/download logic, ensuring reliability across releases.