BranchesTags

Repository files navigation

LFS Cloud

LFS Cloud is a self-hosted Git LFS server and companion CLI. Git repositories and access control stay on GitHub, while large-file bytes are stored in Google Drive.

Git LFS client <-> LFS Cloud <-> Google Drive
|
+-> GitHub permission checks

Each user authenticates with their own GitHub personal access token (PAT). LFS Cloud checks that user's current repository permission for every transfer: read access permits downloads, while write access permits uploads and migration. The CLI also maintains a shared local object cache and uses copy-on-write materialization where supported.

Requirements

  • Git and Git LFS, initialized for the current user
  • a Git credential helper for storing the local LFS Cloud session token
  • Google Cloud CLI (gcloud)
  • a Google Cloud Desktop OAuth client from a project with the Drive API enabled
  • GitHub CLI (gh), authenticated for interactive repository setup
  • a repository-scoped GitHub PAT for each LFS Cloud user

Install

Choose one installation method.

Install Script

On macOS ARM64 or Linux x86-64/ARM64:

curl -fsSL https://github.com/Quicksaver/lfs-cloud/releases/latest/download/install.sh | sh

On Windows x86-64:

irm https://github.com/Quicksaver/lfs-cloud/releases/latest/download/install.ps1 | iex

The scripts verify the release checksum and executable version, install to ~/.local/bin by default, and neither elevate privileges nor modify PATH. See Installer options for version pinning and custom destinations.

Homebrew

On macOS or Linux:

brew install Quicksaver/tap/lfscloud

WinGet

Coming soon. LFS Cloud has been submitted to the WinGet Community Repository but will not be available until the submission is accepted. Once available:

winget install --exact --id Quicksaver.LFSCloud

From Source

This requires Rust 1.88 or newer:

cargo install --locked --path .

Quick Start

1. Prepare Google Drive

Create a Google Cloud Desktop OAuth client, enable the Drive API in its project, and download the client JSON. The Google Drive configuration guide explains the required scopes and folder access.

2. Configure The Server

Run the interactive setup:

lfscloud config repository add
lfscloud config storage add
lfscloud repository add

These commands configure GitHub, authorize an isolated Google Drive credential, and map a GitHub repository to its Drive storage. See Server configuration for the YAML format and non-interactive behavior.

3. Start LFS Cloud

lfscloud serve

4. Connect A Repository

From the configured Git repository:

lfscloud init --server http://127.0.0.1:15370
lfscloud login
lfscloud status

After setup, normal Git and Git LFS pushes and fetches use LFS Cloud. Configure new LFS patterns as usual:

git lfs track "*.bin"
git add .gitattributes .lfsconfig

Client commands use the repository route, local credential helper, and local cache without reading or creating the server's private config.yml.

Human-readable command output and logs use semantic colors when an interactive terminal supports them. Redirected output stays plain; set a non-empty NO_COLOR value, such as NO_COLOR=1, to disable colors explicitly, including in automation that allocates a pseudo-terminal.

See Repository setup for credential-helper, local-only, and network guidance.

Migrate An Existing Repository

Use a non-shallow clone. Migration refreshes the selected source remote's branches and tags before scanning its refs. Keep the existing LFS endpoint configured, then preview and run the migration against LFS Cloud:

lfscloud login
lfscloud migrate --all-refs --dry-run
lfscloud migrate --all-refs
git add .lfsconfig
git commit -m "Route Git LFS through LFS Cloud"

Migration copies LFS objects without rewriting Git history and changes repository configuration only after every target object succeeds. Interrupted runs are safe to retry. See Migration for source selection, configuration changes, and retry behavior.

Limitations And Security

  • GitHub and Google Drive are the only supported providers.
  • Users authenticate with GitHub PATs; OAuth and device-flow login are not supported.
  • Uploads and downloads pass through the LFS Cloud process, so the host must support long-lived large-file transfers.
  • Release binaries are checksummed but are not signed or notarized.
  • LFS Cloud does not provide TLS termination.

The default listener accepts loopback, trusted LAN, and direct Tailscale connections. Plain HTTP over a LAN exposes GitHub PATs during login, local LFS credentials, and object bytes to network observers. Prefer HTTPS on any network you do not fully trust. Direct Tailscale traffic is encrypted by the tailnet tunnel, although the application URL remains HTTP.

Documentation

Run lfscloud --help or lfscloud <command> --help for command and option reference.

License

LFS Cloud is available under the MIT License.

About

A self-hosted Git LFS server and companion CLI

Topics

gitlfsstorage

Resources

Readme
MIT license
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
LFS Cloud
LFS Cloud is a self-hosted Git LFS server and companion CLI. Git repositories and access control stay on GitHub, while large-file bytes are stored in Google Drive.
Git LFS client <-> LFS Cloud <-> Google Drive
|
+-> GitHub permission checks

Each user authenticates with their own GitHub personal access token (PAT). LFS Cloud checks that user's current repository permission for every transfer: read access permits downloads, while write access permits uploads and migration. The CLI also maintains a shared local object cache and uses copy-on-write materialization where supported.
Requirements
  • Git and Git LFS, initialized for the current user
  • a Git credential helper for storing the local LFS Cloud session token
  • Google Cloud CLI (gcloud)
  • a Google Cloud Desktop OAuth client from a project with the Drive API enabled
  • GitHub CLI (gh), authenticated for interactive repository setup
  • a repository-scoped GitHub PAT for each LFS Cloud user
Install
Choose one installation method.
Install Script
On macOS ARM64 or Linux x86-64/ARM64:
curl -fsSL https://github.com/Quicksaver/lfs-cloud/releases/latest/download/install.sh | sh
On Windows x86-64:
irm https://github.com/Quicksaver/lfs-cloud/releases/latest/download/install.ps1 | iex
The scripts verify the release checksum and executable version, install to ~/.local/bin by default, and neither elevate privileges nor modify PATH. See Installer options for version pinning and custom destinations.
Homebrew
On macOS or Linux:
brew install Quicksaver/tap/lfscloud
WinGet
Coming soon. LFS Cloud has been submitted to the WinGet Community Repository but will not be available until the submission is accepted. Once available:
winget install --exact --id Quicksaver.LFSCloud
From Source
This requires Rust 1.88 or newer:
cargo install --locked --path .
Quick Start
1. Prepare Google Drive
Create a Google Cloud Desktop OAuth client, enable the Drive API in its project, and download the client JSON. The Google Drive configuration guide explains the required scopes and folder access.
2. Configure The Server
Run the interactive setup:
lfscloud config repository add
lfscloud config storage add
lfscloud repository add
These commands configure GitHub, authorize an isolated Google Drive credential, and map a GitHub repository to its Drive storage. See Server configuration for the YAML format and non-interactive behavior.
3. Start LFS Cloud
lfscloud serve
4. Connect A Repository
From the configured Git repository:
lfscloud init --server http://127.0.0.1:15370
lfscloud login
lfscloud status
After setup, normal Git and Git LFS pushes and fetches use LFS Cloud. Configure new LFS patterns as usual:
git lfs track "*.bin"
git add .gitattributes .lfsconfig
Client commands use the repository route, local credential helper, and local cache without reading or creating the server's private config.yml.
Human-readable command output and logs use semantic colors when an interactive terminal supports them. Redirected output stays plain; set a non-empty NO_COLOR value, such as NO_COLOR=1, to disable colors explicitly, including in automation that allocates a pseudo-terminal.
See Repository setup for credential-helper, local-only, and network guidance.
Migrate An Existing Repository
Use a non-shallow clone. Migration refreshes the selected source remote's branches and tags before scanning its refs. Keep the existing LFS endpoint configured, then preview and run the migration against LFS Cloud:
lfscloud login
lfscloud migrate --all-refs --dry-run
lfscloud migrate --all-refs
git add .lfsconfig
git commit -m "Route Git LFS through LFS Cloud"
Migration copies LFS objects without rewriting Git history and changes repository configuration only after every target object succeeds. Interrupted runs are safe to retry. See Migration for source selection, configuration changes, and retry behavior.
Limitations And Security
  • GitHub and Google Drive are the only supported providers.
  • Users authenticate with GitHub PATs; OAuth and device-flow login are not supported.
  • Uploads and downloads pass through the LFS Cloud process, so the host must support long-lived large-file transfers.
  • Release binaries are checksummed but are not signed or notarized.
  • LFS Cloud does not provide TLS termination.
The default listener accepts loopback, trusted LAN, and direct Tailscale connections. Plain HTTP over a LAN exposes GitHub PATs during login, local LFS credentials, and object bytes to network observers. Prefer HTTPS on any network you do not fully trust. Direct Tailscale traffic is encrypted by the tailnet tunnel, although the application URL remains HTTP.
Documentation
Run lfscloud --help or lfscloud <command> --help for command and option reference.
License
LFS Cloud is available under the MIT License.
About
A self-hosted Git LFS server and companion CLI 
Topics
gitlfsstorage
Resources
Readme
MIT license
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
LFS Cloud
LFS Cloud is a self-hosted Git LFS server and companion CLI. Git repositories and access control stay on GitHub, while large-file bytes are stored in Google Drive.
Git LFS client <-> LFS Cloud <-> Google Drive
|
+-> GitHub permission checks

Each user authenticates with their own GitHub personal access token (PAT). LFS Cloud checks that user's current repository permission for every transfer: read access permits downloads, while write access permits uploads and migration. The CLI also maintains a shared local object cache and uses copy-on-write materialization where supported.
Requirements
  • Git and Git LFS, initialized for the current user
  • a Git credential helper for storing the local LFS Cloud session token
  • Google Cloud CLI (gcloud)
  • a Google Cloud Desktop OAuth client from a project with the Drive API enabled
  • GitHub CLI (gh), authenticated for interactive repository setup
  • a repository-scoped GitHub PAT for each LFS Cloud user
Install
Choose one installation method.
Install Script
On macOS ARM64 or Linux x86-64/ARM64:
curl -fsSL https://github.com/Quicksaver/lfs-cloud/releases/latest/download/install.sh | sh
On Windows x86-64:
irm https://github.com/Quicksaver/lfs-cloud/releases/latest/download/install.ps1 | iex
The scripts verify the release checksum and executable version, install to ~/.local/bin by default, and neither elevate privileges nor modify PATH. See Installer options for version pinning and custom destinations.
Homebrew
On macOS or Linux:
brew install Quicksaver/tap/lfscloud
WinGet
Coming soon. LFS Cloud has been submitted to the WinGet Community Repository but will not be available until the submission is accepted. Once available:
winget install --exact --id Quicksaver.LFSCloud
From Source
This requires Rust 1.88 or newer:
cargo install --locked --path .
Quick Start
1. Prepare Google Drive
Create a Google Cloud Desktop OAuth client, enable the Drive API in its project, and download the client JSON. The Google Drive configuration guide explains the required scopes and folder access.
2. Configure The Server
Run the interactive setup:
lfscloud config repository add
lfscloud config storage add
lfscloud repository add
These commands configure GitHub, authorize an isolated Google Drive credential, and map a GitHub repository to its Drive storage. See Server configuration for the YAML format and non-interactive behavior.
3. Start LFS Cloud
lfscloud serve
4. Connect A Repository
From the configured Git repository:
lfscloud init --server http://127.0.0.1:15370
lfscloud login
lfscloud status
After setup, normal Git and Git LFS pushes and fetches use LFS Cloud. Configure new LFS patterns as usual:
git lfs track "*.bin"
git add .gitattributes .lfsconfig
Client commands use the repository route, local credential helper, and local cache without reading or creating the server's private config.yml.
Human-readable command output and logs use semantic colors when an interactive terminal supports them. Redirected output stays plain; set a non-empty NO_COLOR value, such as NO_COLOR=1, to disable colors explicitly, including in automation that allocates a pseudo-terminal.
See Repository setup for credential-helper, local-only, and network guidance.
Migrate An Existing Repository
Use a non-shallow clone. Migration refreshes the selected source remote's branches and tags before scanning its refs. Keep the existing LFS endpoint configured, then preview and run the migration against LFS Cloud:
lfscloud login
lfscloud migrate --all-refs --dry-run
lfscloud migrate --all-refs
git add .lfsconfig
git commit -m "Route Git LFS through LFS Cloud"
Migration copies LFS objects without rewriting Git history and changes repository configuration only after every target object succeeds. Interrupted runs are safe to retry. See Migration for source selection, configuration changes, and retry behavior.
Limitations And Security
  • GitHub and Google Drive are the only supported providers.
  • Users authenticate with GitHub PATs; OAuth and device-flow login are not supported.
  • Uploads and downloads pass through the LFS Cloud process, so the host must support long-lived large-file transfers.
  • Release binaries are checksummed but are not signed or notarized.
  • LFS Cloud does not provide TLS termination.
The default listener accepts loopback, trusted LAN, and direct Tailscale connections. Plain HTTP over a LAN exposes GitHub PATs during login, local LFS credentials, and object bytes to network observers. Prefer HTTPS on any network you do not fully trust. Direct Tailscale traffic is encrypted by the tailnet tunnel, although the application URL remains HTTP.
Documentation
Run lfscloud --help or lfscloud <command> --help for command and option reference.
License
LFS Cloud is available under the MIT License.
About
A self-hosted Git LFS server and companion CLI 
Topics
gitlfsstorage
Resources
Readme
MIT license
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms");
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
LFS Cloud
LFS Cloud is a self-hosted Git LFS server and companion CLI. Git repositories and access control stay on GitHub, while large-file bytes are stored in Google Drive.
Git LFS client <-> LFS Cloud <-> Google Drive
|
+-> GitHub permission checks

Each user authenticates with their own GitHub personal access token (PAT). LFS Cloud checks that user's current repository permission for every transfer: read access permits downloads, while write access permits uploads and migration. The CLI also maintains a shared local object cache and uses copy-on-write materialization where supported.
Requirements
  • Git and Git LFS, initialized for the current user
  • a Git credential helper for storing the local LFS Cloud session token
  • Google Cloud CLI (gcloud)
  • a Google Cloud Desktop OAuth client from a project with the Drive API enabled
  • GitHub CLI (gh), authenticated for interactive repository setup
  • a repository-scoped GitHub PAT for each LFS Cloud user
Install
Choose one installation method.
Install Script
On macOS ARM64 or Linux x86-64/ARM64:
curl -fsSL https://github.com/Quicksaver/lfs-cloud/releases/latest/download/install.sh | sh
On Windows x86-64:
irm https://github.com/Quicksaver/lfs-cloud/releases/latest/download/install.ps1 | iex
The scripts verify the release checksum and executable version, install to ~/.local/bin by default, and neither elevate privileges nor modify PATH. See Installer options for version pinning and custom destinations.
Homebrew
On macOS or Linux:
brew install Quicksaver/tap/lfscloud
WinGet
Coming soon. LFS Cloud has been submitted to the WinGet Community Repository but will not be available until the submission is accepted. Once available:
winget install --exact --id Quicksaver.LFSCloud
From Source
This requires Rust 1.88 or newer:
cargo install --locked --path .
Quick Start
1. Prepare Google Drive
Create a Google Cloud Desktop OAuth client, enable the Drive API in its project, and download the client JSON. The Google Drive configuration guide explains the required scopes and folder access.
2. Configure The Server
Run the interactive setup:
lfscloud config repository add
lfscloud config storage add
lfscloud repository add
These commands configure GitHub, authorize an isolated Google Drive credential, and map a GitHub repository to its Drive storage. See Server configuration for the YAML format and non-interactive behavior.
3. Start LFS Cloud
lfscloud serve
4. Connect A Repository
From the configured Git repository:
lfscloud init --server http://127.0.0.1:15370
lfscloud login
lfscloud status
After setup, normal Git and Git LFS pushes and fetches use LFS Cloud. Configure new LFS patterns as usual:
git lfs track "*.bin"
git add .gitattributes .lfsconfig
Client commands use the repository route, local credential helper, and local cache without reading or creating the server's private config.yml.
Human-readable command output and logs use semantic colors when an interactive terminal supports them. Redirected output stays plain; set a non-empty NO_COLOR value, such as NO_COLOR=1, to disable colors explicitly, including in automation that allocates a pseudo-terminal.
See Repository setup for credential-helper, local-only, and network guidance.
Migrate An Existing Repository
Use a non-shallow clone. Migration refreshes the selected source remote's branches and tags before scanning its refs. Keep the existing LFS endpoint configured, then preview and run the migration against LFS Cloud:
lfscloud login
lfscloud migrate --all-refs --dry-run
lfscloud migrate --all-refs
git add .lfsconfig
git commit -m "Route Git LFS through LFS Cloud"
Migration copies LFS objects without rewriting Git history and changes repository configuration only after every target object succeeds. Interrupted runs are safe to retry. See Migration for source selection, configuration changes, and retry behavior.
Limitations And Security
  • GitHub and Google Drive are the only supported providers.
  • Users authenticate with GitHub PATs; OAuth and device-flow login are not supported.
  • Uploads and downloads pass through the LFS Cloud process, so the host must support long-lived large-file transfers.
  • Release binaries are checksummed but are not signed or notarized.
  • LFS Cloud does not provide TLS termination.
The default listener accepts loopback, trusted LAN, and direct Tailscale connections. Plain HTTP over a LAN exposes GitHub PATs during login, local LFS credentials, and object bytes to network observers. Prefer HTTPS on any network you do not fully trust. Direct Tailscale traffic is encrypted by the tailnet tunnel, although the application URL remains HTTP.
Documentation
Run lfscloud --help or lfscloud <command> --help for command and option reference.
License
LFS Cloud is available under the MIT License.
About
A self-hosted Git LFS server and companion CLI 
Topics
gitlfsstorage
Resources
Readme
MIT license
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
LFS Cloud
LFS Cloud is a self-hosted Git LFS server and companion CLI. Git repositories and access control stay on GitHub, while large-file bytes are stored in Google Drive.
Git LFS client <-> LFS Cloud <-> Google Drive
|
+-> GitHub permission checks

Each user authenticates with their own GitHub personal access token (PAT). LFS Cloud checks that user's current repository permission for every transfer: read access permits downloads, while write access permits uploads and migration. The CLI also maintains a shared local object cache and uses copy-on-write materialization where supported.
Requirements
  • Git and Git LFS, initialized for the current user
  • a Git credential helper for storing the local LFS Cloud session token
  • Google Cloud CLI (gcloud)
  • a Google Cloud Desktop OAuth client from a project with the Drive API enabled
  • GitHub CLI (gh), authenticated for interactive repository setup
  • a repository-scoped GitHub PAT for each LFS Cloud user
Install
Choose one installation method.
Install Script
On macOS ARM64 or Linux x86-64/ARM64:
curl -fsSL https://github.com/Quicksaver/lfs-cloud/releases/latest/download/install.sh | sh
On Windows x86-64:
irm https://github.com/Quicksaver/lfs-cloud/releases/latest/download/install.ps1 | iex
The scripts verify the release checksum and executable version, install to ~/.local/bin by default, and neither elevate privileges nor modify PATH. See Installer options for version pinning and custom destinations.
Homebrew
On macOS or Linux:
brew install Quicksaver/tap/lfscloud
WinGet
Coming soon. LFS Cloud has been submitted to the WinGet Community Repository but will not be available until the submission is accepted. Once available:
winget install --exact --id Quicksaver.LFSCloud
From Source
This requires Rust 1.88 or newer:
cargo install --locked --path .
Quick Start
1. Prepare Google Drive
Create a Google Cloud Desktop OAuth client, enable the Drive API in its project, and download the client JSON. The Google Drive configuration guide explains the required scopes and folder access.
2. Configure The Server
Run the interactive setup:
lfscloud config repository add
lfscloud config storage add
lfscloud repository add
These commands configure GitHub, authorize an isolated Google Drive credential, and map a GitHub repository to its Drive storage. See Server configuration for the YAML format and non-interactive behavior.
3. Start LFS Cloud
lfscloud serve
4. Connect A Repository
From the configured Git repository:
lfscloud init --server http://127.0.0.1:15370
lfscloud login
lfscloud status
After setup, normal Git and Git LFS pushes and fetches use LFS Cloud. Configure new LFS patterns as usual:
git lfs track "*.bin"
git add .gitattributes .lfsconfig
Client commands use the repository route, local credential helper, and local cache without reading or creating the server's private config.yml.
Human-readable command output and logs use semantic colors when an interactive terminal supports them. Redirected output stays plain; set a non-empty NO_COLOR value, such as NO_COLOR=1, to disable colors explicitly, including in automation that allocates a pseudo-terminal.
See Repository setup for credential-helper, local-only, and network guidance.
Migrate An Existing Repository
Use a non-shallow clone. Migration refreshes the selected source remote's branches and tags before scanning its refs. Keep the existing LFS endpoint configured, then preview and run the migration against LFS Cloud:
lfscloud login
lfscloud migrate --all-refs --dry-run
lfscloud migrate --all-refs
git add .lfsconfig
git commit -m "Route Git LFS through LFS Cloud"
Migration copies LFS objects without rewriting Git history and changes repository configuration only after every target object succeeds. Interrupted runs are safe to retry. See Migration for source selection, configuration changes, and retry behavior.
Limitations And Security
  • GitHub and Google Drive are the only supported providers.
  • Users authenticate with GitHub PATs; OAuth and device-flow login are not supported.
  • Uploads and downloads pass through the LFS Cloud process, so the host must support long-lived large-file transfers.
  • Release binaries are checksummed but are not signed or notarized.
  • LFS Cloud does not provide TLS termination.
The default listener accepts loopback, trusted LAN, and direct Tailscale connections. Plain HTTP over a LAN exposes GitHub PATs during login, local LFS credentials, and object bytes to network observers. Prefer HTTPS on any network you do not fully trust. Direct Tailscale traffic is encrypted by the tailnet tunnel, although the application URL remains HTTP.
Documentation
Run lfscloud --help or lfscloud <command> --help for command and option reference.
License
LFS Cloud is available under the MIT License.
About
A self-hosted Git LFS server and companion CLI 
Topics
gitlfsstorage
Resources
Readme
MIT license
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
LFS Cloud
LFS Cloud is a self-hosted Git LFS server and companion CLI. Git repositories and access control stay on GitHub, while large-file bytes are stored in Google Drive.
Git LFS client <-> LFS Cloud <-> Google Drive
|
+-> GitHub permission checks

Each user authenticates with their own GitHub personal access token (PAT). LFS Cloud checks that user's current repository permission for every transfer: read access permits downloads, while write access permits uploads and migration. The CLI also maintains a shared local object cache and uses copy-on-write materialization where supported.
Requirements
  • Git and Git LFS, initialized for the current user
  • a Git credential helper for storing the local LFS Cloud session token
  • Google Cloud CLI (gcloud)
  • a Google Cloud Desktop OAuth client from a project with the Drive API enabled
  • GitHub CLI (gh), authenticated for interactive repository setup
  • a repository-scoped GitHub PAT for each LFS Cloud user
Install
Choose one installation method.
Install Script
On macOS ARM64 or Linux x86-64/ARM64:
curl -fsSL https://github.com/Quicksaver/lfs-cloud/releases/latest/download/install.sh | sh
On Windows x86-64:
irm https://github.com/Quicksaver/lfs-cloud/releases/latest/download/install.ps1 | iex
The scripts verify the release checksum and executable version, install to ~/.local/bin by default, and neither elevate privileges nor modify PATH. See Installer options for version pinning and custom destinations.
Homebrew
On macOS or Linux:
brew install Quicksaver/tap/lfscloud
WinGet
Coming soon. LFS Cloud has been submitted to the WinGet Community Repository but will not be available until the submission is accepted. Once available:
winget install --exact --id Quicksaver.LFSCloud
From Source
This requires Rust 1.88 or newer:
cargo install --locked --path .
Quick Start
1. Prepare Google Drive
Create a Google Cloud Desktop OAuth client, enable the Drive API in its project, and download the client JSON. The Google Drive configuration guide explains the required scopes and folder access.
2. Configure The Server
Run the interactive setup:
lfscloud config repository add
lfscloud config storage add
lfscloud repository add
These commands configure GitHub, authorize an isolated Google Drive credential, and map a GitHub repository to its Drive storage. See Server configuration for the YAML format and non-interactive behavior.
3. Start LFS Cloud
lfscloud serve
4. Connect A Repository
From the configured Git repository:
lfscloud init --server http://127.0.0.1:15370
lfscloud login
lfscloud status
After setup, normal Git and Git LFS pushes and fetches use LFS Cloud. Configure new LFS patterns as usual:
git lfs track "*.bin"
git add .gitattributes .lfsconfig
Client commands use the repository route, local credential helper, and local cache without reading or creating the server's private config.yml.
Human-readable command output and logs use semantic colors when an interactive terminal supports them. Redirected output stays plain; set a non-empty NO_COLOR value, such as NO_COLOR=1, to disable colors explicitly, including in automation that allocates a pseudo-terminal.
See Repository setup for credential-helper, local-only, and network guidance.
Migrate An Existing Repository
Use a non-shallow clone. Migration refreshes the selected source remote's branches and tags before scanning its refs. Keep the existing LFS endpoint configured, then preview and run the migration against LFS Cloud:
lfscloud login
lfscloud migrate --all-refs --dry-run
lfscloud migrate --all-refs
git add .lfsconfig
git commit -m "Route Git LFS through LFS Cloud"
Migration copies LFS objects without rewriting Git history and changes repository configuration only after every target object succeeds. Interrupted runs are safe to retry. See Migration for source selection, configuration changes, and retry behavior.
Limitations And Security
  • GitHub and Google Drive are the only supported providers.
  • Users authenticate with GitHub PATs; OAuth and device-flow login are not supported.
  • Uploads and downloads pass through the LFS Cloud process, so the host must support long-lived large-file transfers.
  • Release binaries are checksummed but are not signed or notarized.
  • LFS Cloud does not provide TLS termination.
The default listener accepts loopback, trusted LAN, and direct Tailscale connections. Plain HTTP over a LAN exposes GitHub PATs during login, local LFS credentials, and object bytes to network observers. Prefer HTTPS on any network you do not fully trust. Direct Tailscale traffic is encrypted by the tailnet tunnel, although the application URL remains HTTP.
Documentation
Run lfscloud --help or lfscloud <command> --help for command and option reference.
License
LFS Cloud is available under the MIT License.
About
A self-hosted Git LFS server and companion CLI 
Topics
gitlfsstorage
Resources
Readme
MIT license
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers");
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
LFS Cloud
LFS Cloud is a self-hosted Git LFS server and companion CLI. Git repositories and access control stay on GitHub, while large-file bytes are stored in Google Drive.
Git LFS client <-> LFS Cloud <-> Google Drive
|
+-> GitHub permission checks

Each user authenticates with their own GitHub personal access token (PAT). LFS Cloud checks that user's current repository permission for every transfer: read access permits downloads, while write access permits uploads and migration. The CLI also maintains a shared local object cache and uses copy-on-write materialization where supported.
Requirements
  • Git and Git LFS, initialized for the current user
  • a Git credential helper for storing the local LFS Cloud session token
  • Google Cloud CLI (gcloud)
  • a Google Cloud Desktop OAuth client from a project with the Drive API enabled
  • GitHub CLI (gh), authenticated for interactive repository setup
  • a repository-scoped GitHub PAT for each LFS Cloud user
Install
Choose one installation method.
Install Script
On macOS ARM64 or Linux x86-64/ARM64:
curl -fsSL https://github.com/Quicksaver/lfs-cloud/releases/latest/download/install.sh | sh
On Windows x86-64:
irm https://github.com/Quicksaver/lfs-cloud/releases/latest/download/install.ps1 | iex
The scripts verify the release checksum and executable version, install to ~/.local/bin by default, and neither elevate privileges nor modify PATH. See Installer options for version pinning and custom destinations.
Homebrew
On macOS or Linux:
brew install Quicksaver/tap/lfscloud
WinGet
Coming soon. LFS Cloud has been submitted to the WinGet Community Repository but will not be available until the submission is accepted. Once available:
winget install --exact --id Quicksaver.LFSCloud
From Source
This requires Rust 1.88 or newer:
cargo install --locked --path .
Quick Start
1. Prepare Google Drive
Create a Google Cloud Desktop OAuth client, enable the Drive API in its project, and download the client JSON. The Google Drive configuration guide explains the required scopes and folder access.
2. Configure The Server
Run the interactive setup:
lfscloud config repository add
lfscloud config storage add
lfscloud repository add
These commands configure GitHub, authorize an isolated Google Drive credential, and map a GitHub repository to its Drive storage. See Server configuration for the YAML format and non-interactive behavior.
3. Start LFS Cloud
lfscloud serve
4. Connect A Repository
From the configured Git repository:
lfscloud init --server http://127.0.0.1:15370
lfscloud login
lfscloud status
After setup, normal Git and Git LFS pushes and fetches use LFS Cloud. Configure new LFS patterns as usual:
git lfs track "*.bin"
git add .gitattributes .lfsconfig
Client commands use the repository route, local credential helper, and local cache without reading or creating the server's private config.yml.
Human-readable command output and logs use semantic colors when an interactive terminal supports them. Redirected output stays plain; set a non-empty NO_COLOR value, such as NO_COLOR=1, to disable colors explicitly, including in automation that allocates a pseudo-terminal.
See Repository setup for credential-helper, local-only, and network guidance.
Migrate An Existing Repository
Use a non-shallow clone. Migration refreshes the selected source remote's branches and tags before scanning its refs. Keep the existing LFS endpoint configured, then preview and run the migration against LFS Cloud:
lfscloud login
lfscloud migrate --all-refs --dry-run
lfscloud migrate --all-refs
git add .lfsconfig
git commit -m "Route Git LFS through LFS Cloud"
Migration copies LFS objects without rewriting Git history and changes repository configuration only after every target object succeeds. Interrupted runs are safe to retry. See Migration for source selection, configuration changes, and retry behavior.
Limitations And Security
  • GitHub and Google Drive are the only supported providers.
  • Users authenticate with GitHub PATs; OAuth and device-flow login are not supported.
  • Uploads and downloads pass through the LFS Cloud process, so the host must support long-lived large-file transfers.
  • Release binaries are checksummed but are not signed or notarized.
  • LFS Cloud does not provide TLS termination.
The default listener accepts loopback, trusted LAN, and direct Tailscale connections. Plain HTTP over a LAN exposes GitHub PATs during login, local LFS credentials, and object bytes to network observers. Prefer HTTPS on any network you do not fully trust. Direct Tailscale traffic is encrypted by the tailnet tunnel, although the application URL remains HTTP.
Documentation
Run lfscloud --help or lfscloud <command> --help for command and option reference.
License
LFS Cloud is available under the MIT License.
About
A self-hosted Git LFS server and companion CLI 
Topics
gitlfsstorage
Resources
Readme
MIT license
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode");
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
LFS Cloud
LFS Cloud is a self-hosted Git LFS server and companion CLI. Git repositories and access control stay on GitHub, while large-file bytes are stored in Google Drive.
Git LFS client <-> LFS Cloud <-> Google Drive
|
+-> GitHub permission checks

Each user authenticates with their own GitHub personal access token (PAT). LFS Cloud checks that user's current repository permission for every transfer: read access permits downloads, while write access permits uploads and migration. The CLI also maintains a shared local object cache and uses copy-on-write materialization where supported.
Requirements
  • Git and Git LFS, initialized for the current user
  • a Git credential helper for storing the local LFS Cloud session token
  • Google Cloud CLI (gcloud)
  • a Google Cloud Desktop OAuth client from a project with the Drive API enabled
  • GitHub CLI (gh), authenticated for interactive repository setup
  • a repository-scoped GitHub PAT for each LFS Cloud user
Install
Choose one installation method.
Install Script
On macOS ARM64 or Linux x86-64/ARM64:
curl -fsSL https://github.com/Quicksaver/lfs-cloud/releases/latest/download/install.sh | sh
On Windows x86-64:
irm https://github.com/Quicksaver/lfs-cloud/releases/latest/download/install.ps1 | iex
The scripts verify the release checksum and executable version, install to ~/.local/bin by default, and neither elevate privileges nor modify PATH. See Installer options for version pinning and custom destinations.
Homebrew
On macOS or Linux:
brew install Quicksaver/tap/lfscloud
WinGet
Coming soon. LFS Cloud has been submitted to the WinGet Community Repository but will not be available until the submission is accepted. Once available:
winget install --exact --id Quicksaver.LFSCloud
From Source
This requires Rust 1.88 or newer:
cargo install --locked --path .
Quick Start
1. Prepare Google Drive
Create a Google Cloud Desktop OAuth client, enable the Drive API in its project, and download the client JSON. The Google Drive configuration guide explains the required scopes and folder access.
2. Configure The Server
Run the interactive setup:
lfscloud config repository add
lfscloud config storage add
lfscloud repository add
These commands configure GitHub, authorize an isolated Google Drive credential, and map a GitHub repository to its Drive storage. See Server configuration for the YAML format and non-interactive behavior.
3. Start LFS Cloud
lfscloud serve
4. Connect A Repository
From the configured Git repository:
lfscloud init --server http://127.0.0.1:15370
lfscloud login
lfscloud status
After setup, normal Git and Git LFS pushes and fetches use LFS Cloud. Configure new LFS patterns as usual:
git lfs track "*.bin"
git add .gitattributes .lfsconfig
Client commands use the repository route, local credential helper, and local cache without reading or creating the server's private config.yml.
Human-readable command output and logs use semantic colors when an interactive terminal supports them. Redirected output stays plain; set a non-empty NO_COLOR value, such as NO_COLOR=1, to disable colors explicitly, including in automation that allocates a pseudo-terminal.
See Repository setup for credential-helper, local-only, and network guidance.
Migrate An Existing Repository
Use a non-shallow clone. Migration refreshes the selected source remote's branches and tags before scanning its refs. Keep the existing LFS endpoint configured, then preview and run the migration against LFS Cloud:
lfscloud login
lfscloud migrate --all-refs --dry-run
lfscloud migrate --all-refs
git add .lfsconfig
git commit -m "Route Git LFS through LFS Cloud"
Migration copies LFS objects without rewriting Git history and changes repository configuration only after every target object succeeds. Interrupted runs are safe to retry. See Migration for source selection, configuration changes, and retry behavior.
Limitations And Security
  • GitHub and Google Drive are the only supported providers.
  • Users authenticate with GitHub PATs; OAuth and device-flow login are not supported.
  • Uploads and downloads pass through the LFS Cloud process, so the host must support long-lived large-file transfers.
  • Release binaries are checksummed but are not signed or notarized.
  • LFS Cloud does not provide TLS termination.
The default listener accepts loopback, trusted LAN, and direct Tailscale connections. Plain HTTP over a LAN exposes GitHub PATs during login, local LFS credentials, and object bytes to network observers. Prefer HTTPS on any network you do not fully trust. Direct Tailscale traffic is encrypted by the tailnet tunnel, although the application URL remains HTTP.
Documentation
Run lfscloud --help or lfscloud <command> --help for command and option reference.
License
LFS Cloud is available under the MIT License.
About
A self-hosted Git LFS server and companion CLI 
Topics
gitlfsstorage
Resources
Readme
MIT license
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages