Skip to content
BranchesTags

Repository files navigation

claun

Note: Claude Code now has a similar feature! You should probably just use /loop!

Claun TUI

Schedule Claude Code jobs with a TUI or headless mode. Sometimes systemd is just overkill. Pronounced "Klon" like the guitar pedal.

In all seriousness, the purpose of this tool is to quickly prototype workflows, or for something that is going to run on your dev desktop (like pulling/fixing bugs and submitting PRs). Please don't use it for a production pipeline! If you want to build something that you can rely on, please use systemd or Kinesis/Glue/Lambda (or I guess cron if you are old school like that). I am not responsible for any 3am pages when this falls over ;)

Installation

pip install claun-tui

Quick Start

# Launch TUI (default)
claun
# Launch TUI with pre-filled command
claun -c "Review our metrics from the past hour for anomalies"# Run in headless mode
claun -H -c "Update bug list from Linear MCP and fix" -m 60
# See what would run without executing
claun --dry-run -c "test command"

Features

  • Simple TUI: Single-page interface with all controls visible - no menu diving
  • Headless mode: Run as a background service with terminal output
  • Flexible scheduling: Days of week, hour ranges, minute intervals
  • Job timeout: Configurable timeout kills stuck processes (default: 120s)
  • Claude flags: Pass any flags to claude (like --resume for session persistence)
  • Simple logging: Automatic log files with browseable history

TUI Mode

Launch with claun to get an interactive interface with:

  • Command input field
  • Optional Claude flags (e.g., --resume <session-id> or --model sonnet)
  • Timeout setting (seconds, 0 to disable)
  • Day-of-week toggles (M T W T F S S)
  • Minute interval selector (1, 5, 15, or 60 minutes)
  • Big countdown clock to next run
  • Pause/Resume control
  • Live output log

Keyboard shortcuts:

  • q - Quit
  • p - Pause/Resume
  • r - Run now
  • c - Clear log

Headless Mode

Run without TUI for background/automated use:

# Every 15 minutes (default)
claun -H -c "Check for issues"# Hourly during work hours
claun -H -c "Status update" --hours "9am-5pm" -m 60
# Weekdays only
claun -H -c "Daily standup" --weekdays -m 60

Job Timeout

Jobs have a default timeout of 120 seconds. If a job exceeds the timeout, the process is killed and the next cycle proceeds normally.

# Set a 5-minute timeout
claun -c "Big refactor" --timeout 300
# Disable timeout entirely
claun -c "Long-running task" --timeout 0
# Run once with a short timeout
claun --once -c "Quick check" --timeout 30

In the TUI, the timeout is editable via the "Timeout" input field. The timeout_seconds field is also saved/loaded from .claun.json config files.

Session Persistence

To resume a previous Claude Code session, use the --flags option to pass --resume:

# First, note your session ID from a previous run# Then resume it:
claun -c "Continue working on the feature" -f "--resume abc123-def456"# In the TUI, enter in the "Claude Flags" field:# --resume abc123-def456

You can also pass other claude flags:

# Use a specific model
claun -c "Pull and fix bugs from the Linear MCP, run /code-simplifier and push PRs" -f "--model opus"# Enable web search
claun -c "What is the score of the Niners/Seahawks game?" -f "--allowedTools WebSearch"# Combine multiple flags
claun -c "Fix the next bug on the bug list" -f "--resume abc123 --model sonnet"

CLI Options

Options:
-c, --command TEXT Claude Code command to run
-f, --flags TEXT Extra flags for claude (e.g., '--resume abc123')
-H, --headless Run in headless mode (no TUI)
-d, --days TEXT Days to run (mon,tue,wed,thu,fri,sat,sun)
--weekdays Run only on weekdays (mon-fri)
--weekends Run only on weekends (sat-sun)
--hours TEXT Hour range (e.g., '9-17' or '9am-5pm')
-m, --minutes [1|5|15|60] Minute interval
-t, --timeout INTEGER Timeout in seconds per job (default: 120, 0 to disable)
-l, --log-path PATH Directory for log files
--log-id TEXT Optional ID prefix for log filenames
-P, --paused Start in paused state
--once Run once immediately and exit
--dry-run Show schedule without executing
-v, --version Show version

Subcommands

Browse Logs

# List recent logs in current directory
claun logs
# List logs from specific path
claun logs --path /var/log/claun
# Limit to 10 most recent
claun logs -n 10

Log Files

Logs are saved as: [log_id_]claun_YYYYMMDD_HHMMSS_microseconds.txt

Examples:

  • claun_20260112_143022_123456.txt
  • myproject_claun_20260112_143022_789012.txt (with --log-id)

License

GPL-3.0

About

Use claun to run Claude Code jobs on timers. Sometimes systemd is just overkill.

Resources

Readme
GPL-3.0 license
Activity

Stars

8 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
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;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - nsmith/claun: Use claun to run Claude Code jobs on timers. Sometimes systemd is just overkill. · GitHub
Skip to content
BranchesTags
Repository files navigation
claun
Note: Claude Code now has a similar feature! You should probably just use /loop!
Claun TUI
Schedule Claude Code jobs with a TUI or headless mode. Sometimes systemd is just overkill. Pronounced "Klon" like the guitar pedal.
In all seriousness, the purpose of this tool is to quickly prototype workflows, or for something that is going to run on your dev desktop (like pulling/fixing bugs and submitting PRs). Please don't use it for a production pipeline! If you want to build something that you can rely on, please use systemd or Kinesis/Glue/Lambda (or I guess cron if you are old school like that). I am not responsible for any 3am pages when this falls over ;)
Installation
pip install claun-tui
Quick Start
# Launch TUI (default)
claun
# Launch TUI with pre-filled command
claun -c "Review our metrics from the past hour for anomalies"# Run in headless mode
claun -H -c "Update bug list from Linear MCP and fix" -m 60
# See what would run without executing
claun --dry-run -c "test command"
Features
  • Simple TUI: Single-page interface with all controls visible - no menu diving
  • Headless mode: Run as a background service with terminal output
  • Flexible scheduling: Days of week, hour ranges, minute intervals
  • Job timeout: Configurable timeout kills stuck processes (default: 120s)
  • Claude flags: Pass any flags to claude (like --resume for session persistence)
  • Simple logging: Automatic log files with browseable history
TUI Mode
Launch with claun to get an interactive interface with:
  • Command input field
  • Optional Claude flags (e.g., --resume <session-id> or --model sonnet)
  • Timeout setting (seconds, 0 to disable)
  • Day-of-week toggles (M T W T F S S)
  • Minute interval selector (1, 5, 15, or 60 minutes)
  • Big countdown clock to next run
  • Pause/Resume control
  • Live output log
Keyboard shortcuts:
  • q - Quit
  • p - Pause/Resume
  • r - Run now
  • c - Clear log
Headless Mode
Run without TUI for background/automated use:
# Every 15 minutes (default)
claun -H -c "Check for issues"# Hourly during work hours
claun -H -c "Status update" --hours "9am-5pm" -m 60
# Weekdays only
claun -H -c "Daily standup" --weekdays -m 60
Job Timeout
Jobs have a default timeout of 120 seconds. If a job exceeds the timeout, the process is killed and the next cycle proceeds normally.
# Set a 5-minute timeout
claun -c "Big refactor" --timeout 300
# Disable timeout entirely
claun -c "Long-running task" --timeout 0
# Run once with a short timeout
claun --once -c "Quick check" --timeout 30
In the TUI, the timeout is editable via the "Timeout" input field. The timeout_seconds field is also saved/loaded from .claun.json config files.
Session Persistence
To resume a previous Claude Code session, use the --flags option to pass --resume:
# First, note your session ID from a previous run# Then resume it:
claun -c "Continue working on the feature" -f "--resume abc123-def456"# In the TUI, enter in the "Claude Flags" field:# --resume abc123-def456
You can also pass other claude flags:
# Use a specific model
claun -c "Pull and fix bugs from the Linear MCP, run /code-simplifier and push PRs" -f "--model opus"# Enable web search
claun -c "What is the score of the Niners/Seahawks game?" -f "--allowedTools WebSearch"# Combine multiple flags
claun -c "Fix the next bug on the bug list" -f "--resume abc123 --model sonnet"
CLI Options
Options:
-c, --command TEXT Claude Code command to run
-f, --flags TEXT Extra flags for claude (e.g., '--resume abc123')
-H, --headless Run in headless mode (no TUI)
-d, --days TEXT Days to run (mon,tue,wed,thu,fri,sat,sun)
--weekdays Run only on weekdays (mon-fri)
--weekends Run only on weekends (sat-sun)
--hours TEXT Hour range (e.g., '9-17' or '9am-5pm')
-m, --minutes [1|5|15|60] Minute interval
-t, --timeout INTEGER Timeout in seconds per job (default: 120, 0 to disable)
-l, --log-path PATH Directory for log files
--log-id TEXT Optional ID prefix for log filenames
-P, --paused Start in paused state
--once Run once immediately and exit
--dry-run Show schedule without executing
-v, --version Show version

Subcommands
Browse Logs
# List recent logs in current directory
claun logs
# List logs from specific path
claun logs --path /var/log/claun
# Limit to 10 most recent
claun logs -n 10
Log Files
Logs are saved as: [log_id_]claun_YYYYMMDD_HHMMSS_microseconds.txt
Examples:
  • claun_20260112_143022_123456.txt
  • myproject_claun_20260112_143022_789012.txt (with --log-id)
License
GPL-3.0
About
Use claun to run Claude Code jobs on timers. Sometimes systemd is just overkill.
Resources
Readme
GPL-3.0 license
Activity
Stars
8 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - nsmith/claun: Use claun to run Claude Code jobs on timers. Sometimes systemd is just overkill. · GitHub
Skip to content
BranchesTags
Repository files navigation
claun
Note: Claude Code now has a similar feature! You should probably just use /loop!
Claun TUI
Schedule Claude Code jobs with a TUI or headless mode. Sometimes systemd is just overkill. Pronounced "Klon" like the guitar pedal.
In all seriousness, the purpose of this tool is to quickly prototype workflows, or for something that is going to run on your dev desktop (like pulling/fixing bugs and submitting PRs). Please don't use it for a production pipeline! If you want to build something that you can rely on, please use systemd or Kinesis/Glue/Lambda (or I guess cron if you are old school like that). I am not responsible for any 3am pages when this falls over ;)
Installation
pip install claun-tui
Quick Start
# Launch TUI (default)
claun
# Launch TUI with pre-filled command
claun -c "Review our metrics from the past hour for anomalies"# Run in headless mode
claun -H -c "Update bug list from Linear MCP and fix" -m 60
# See what would run without executing
claun --dry-run -c "test command"
Features
  • Simple TUI: Single-page interface with all controls visible - no menu diving
  • Headless mode: Run as a background service with terminal output
  • Flexible scheduling: Days of week, hour ranges, minute intervals
  • Job timeout: Configurable timeout kills stuck processes (default: 120s)
  • Claude flags: Pass any flags to claude (like --resume for session persistence)
  • Simple logging: Automatic log files with browseable history
TUI Mode
Launch with claun to get an interactive interface with:
  • Command input field
  • Optional Claude flags (e.g., --resume <session-id> or --model sonnet)
  • Timeout setting (seconds, 0 to disable)
  • Day-of-week toggles (M T W T F S S)
  • Minute interval selector (1, 5, 15, or 60 minutes)
  • Big countdown clock to next run
  • Pause/Resume control
  • Live output log
Keyboard shortcuts:
  • q - Quit
  • p - Pause/Resume
  • r - Run now
  • c - Clear log
Headless Mode
Run without TUI for background/automated use:
# Every 15 minutes (default)
claun -H -c "Check for issues"# Hourly during work hours
claun -H -c "Status update" --hours "9am-5pm" -m 60
# Weekdays only
claun -H -c "Daily standup" --weekdays -m 60
Job Timeout
Jobs have a default timeout of 120 seconds. If a job exceeds the timeout, the process is killed and the next cycle proceeds normally.
# Set a 5-minute timeout
claun -c "Big refactor" --timeout 300
# Disable timeout entirely
claun -c "Long-running task" --timeout 0
# Run once with a short timeout
claun --once -c "Quick check" --timeout 30
In the TUI, the timeout is editable via the "Timeout" input field. The timeout_seconds field is also saved/loaded from .claun.json config files.
Session Persistence
To resume a previous Claude Code session, use the --flags option to pass --resume:
# First, note your session ID from a previous run# Then resume it:
claun -c "Continue working on the feature" -f "--resume abc123-def456"# In the TUI, enter in the "Claude Flags" field:# --resume abc123-def456
You can also pass other claude flags:
# Use a specific model
claun -c "Pull and fix bugs from the Linear MCP, run /code-simplifier and push PRs" -f "--model opus"# Enable web search
claun -c "What is the score of the Niners/Seahawks game?" -f "--allowedTools WebSearch"# Combine multiple flags
claun -c "Fix the next bug on the bug list" -f "--resume abc123 --model sonnet"
CLI Options
Options:
-c, --command TEXT Claude Code command to run
-f, --flags TEXT Extra flags for claude (e.g., '--resume abc123')
-H, --headless Run in headless mode (no TUI)
-d, --days TEXT Days to run (mon,tue,wed,thu,fri,sat,sun)
--weekdays Run only on weekdays (mon-fri)
--weekends Run only on weekends (sat-sun)
--hours TEXT Hour range (e.g., '9-17' or '9am-5pm')
-m, --minutes [1|5|15|60] Minute interval
-t, --timeout INTEGER Timeout in seconds per job (default: 120, 0 to disable)
-l, --log-path PATH Directory for log files
--log-id TEXT Optional ID prefix for log filenames
-P, --paused Start in paused state
--once Run once immediately and exit
--dry-run Show schedule without executing
-v, --version Show version

Subcommands
Browse Logs
# List recent logs in current directory
claun logs
# List logs from specific path
claun logs --path /var/log/claun
# Limit to 10 most recent
claun logs -n 10
Log Files
Logs are saved as: [log_id_]claun_YYYYMMDD_HHMMSS_microseconds.txt
Examples:
  • claun_20260112_143022_123456.txt
  • myproject_claun_20260112_143022_789012.txt (with --log-id)
License
GPL-3.0
About
Use claun to run Claude Code jobs on timers. Sometimes systemd is just overkill.
Resources
Readme
GPL-3.0 license
Activity
Stars
8 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - nsmith/claun: Use claun to run Claude Code jobs on timers. Sometimes systemd is just overkill. · GitHub
Skip to content
BranchesTags
Repository files navigation
claun
Note: Claude Code now has a similar feature! You should probably just use /loop!
Claun TUI
Schedule Claude Code jobs with a TUI or headless mode. Sometimes systemd is just overkill. Pronounced "Klon" like the guitar pedal.
In all seriousness, the purpose of this tool is to quickly prototype workflows, or for something that is going to run on your dev desktop (like pulling/fixing bugs and submitting PRs). Please don't use it for a production pipeline! If you want to build something that you can rely on, please use systemd or Kinesis/Glue/Lambda (or I guess cron if you are old school like that). I am not responsible for any 3am pages when this falls over ;)
Installation
pip install claun-tui
Quick Start
# Launch TUI (default)
claun
# Launch TUI with pre-filled command
claun -c "Review our metrics from the past hour for anomalies"# Run in headless mode
claun -H -c "Update bug list from Linear MCP and fix" -m 60
# See what would run without executing
claun --dry-run -c "test command"
Features
  • Simple TUI: Single-page interface with all controls visible - no menu diving
  • Headless mode: Run as a background service with terminal output
  • Flexible scheduling: Days of week, hour ranges, minute intervals
  • Job timeout: Configurable timeout kills stuck processes (default: 120s)
  • Claude flags: Pass any flags to claude (like --resume for session persistence)
  • Simple logging: Automatic log files with browseable history
TUI Mode
Launch with claun to get an interactive interface with:
  • Command input field
  • Optional Claude flags (e.g., --resume <session-id> or --model sonnet)
  • Timeout setting (seconds, 0 to disable)
  • Day-of-week toggles (M T W T F S S)
  • Minute interval selector (1, 5, 15, or 60 minutes)
  • Big countdown clock to next run
  • Pause/Resume control
  • Live output log
Keyboard shortcuts:
  • q - Quit
  • p - Pause/Resume
  • r - Run now
  • c - Clear log
Headless Mode
Run without TUI for background/automated use:
# Every 15 minutes (default)
claun -H -c "Check for issues"# Hourly during work hours
claun -H -c "Status update" --hours "9am-5pm" -m 60
# Weekdays only
claun -H -c "Daily standup" --weekdays -m 60
Job Timeout
Jobs have a default timeout of 120 seconds. If a job exceeds the timeout, the process is killed and the next cycle proceeds normally.
# Set a 5-minute timeout
claun -c "Big refactor" --timeout 300
# Disable timeout entirely
claun -c "Long-running task" --timeout 0
# Run once with a short timeout
claun --once -c "Quick check" --timeout 30
In the TUI, the timeout is editable via the "Timeout" input field. The timeout_seconds field is also saved/loaded from .claun.json config files.
Session Persistence
To resume a previous Claude Code session, use the --flags option to pass --resume:
# First, note your session ID from a previous run# Then resume it:
claun -c "Continue working on the feature" -f "--resume abc123-def456"# In the TUI, enter in the "Claude Flags" field:# --resume abc123-def456
You can also pass other claude flags:
# Use a specific model
claun -c "Pull and fix bugs from the Linear MCP, run /code-simplifier and push PRs" -f "--model opus"# Enable web search
claun -c "What is the score of the Niners/Seahawks game?" -f "--allowedTools WebSearch"# Combine multiple flags
claun -c "Fix the next bug on the bug list" -f "--resume abc123 --model sonnet"
CLI Options
Options:
-c, --command TEXT Claude Code command to run
-f, --flags TEXT Extra flags for claude (e.g., '--resume abc123')
-H, --headless Run in headless mode (no TUI)
-d, --days TEXT Days to run (mon,tue,wed,thu,fri,sat,sun)
--weekdays Run only on weekdays (mon-fri)
--weekends Run only on weekends (sat-sun)
--hours TEXT Hour range (e.g., '9-17' or '9am-5pm')
-m, --minutes [1|5|15|60] Minute interval
-t, --timeout INTEGER Timeout in seconds per job (default: 120, 0 to disable)
-l, --log-path PATH Directory for log files
--log-id TEXT Optional ID prefix for log filenames
-P, --paused Start in paused state
--once Run once immediately and exit
--dry-run Show schedule without executing
-v, --version Show version

Subcommands
Browse Logs
# List recent logs in current directory
claun logs
# List logs from specific path
claun logs --path /var/log/claun
# Limit to 10 most recent
claun logs -n 10
Log Files
Logs are saved as: [log_id_]claun_YYYYMMDD_HHMMSS_microseconds.txt
Examples:
  • claun_20260112_143022_123456.txt
  • myproject_claun_20260112_143022_789012.txt (with --log-id)
License
GPL-3.0
About
Use claun to run Claude Code jobs on timers. Sometimes systemd is just overkill.
Resources
Readme
GPL-3.0 license
Activity
Stars
8 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - nsmith/claun: Use claun to run Claude Code jobs on timers. Sometimes systemd is just overkill. · GitHub
Skip to content
BranchesTags
Repository files navigation
claun
Note: Claude Code now has a similar feature! You should probably just use /loop!
Claun TUI
Schedule Claude Code jobs with a TUI or headless mode. Sometimes systemd is just overkill. Pronounced "Klon" like the guitar pedal.
In all seriousness, the purpose of this tool is to quickly prototype workflows, or for something that is going to run on your dev desktop (like pulling/fixing bugs and submitting PRs). Please don't use it for a production pipeline! If you want to build something that you can rely on, please use systemd or Kinesis/Glue/Lambda (or I guess cron if you are old school like that). I am not responsible for any 3am pages when this falls over ;)
Installation
pip install claun-tui
Quick Start
# Launch TUI (default)
claun
# Launch TUI with pre-filled command
claun -c "Review our metrics from the past hour for anomalies"# Run in headless mode
claun -H -c "Update bug list from Linear MCP and fix" -m 60
# See what would run without executing
claun --dry-run -c "test command"
Features
  • Simple TUI: Single-page interface with all controls visible - no menu diving
  • Headless mode: Run as a background service with terminal output
  • Flexible scheduling: Days of week, hour ranges, minute intervals
  • Job timeout: Configurable timeout kills stuck processes (default: 120s)
  • Claude flags: Pass any flags to claude (like --resume for session persistence)
  • Simple logging: Automatic log files with browseable history
TUI Mode
Launch with claun to get an interactive interface with:
  • Command input field
  • Optional Claude flags (e.g., --resume <session-id> or --model sonnet)
  • Timeout setting (seconds, 0 to disable)
  • Day-of-week toggles (M T W T F S S)
  • Minute interval selector (1, 5, 15, or 60 minutes)
  • Big countdown clock to next run
  • Pause/Resume control
  • Live output log
Keyboard shortcuts:
  • q - Quit
  • p - Pause/Resume
  • r - Run now
  • c - Clear log
Headless Mode
Run without TUI for background/automated use:
# Every 15 minutes (default)
claun -H -c "Check for issues"# Hourly during work hours
claun -H -c "Status update" --hours "9am-5pm" -m 60
# Weekdays only
claun -H -c "Daily standup" --weekdays -m 60
Job Timeout
Jobs have a default timeout of 120 seconds. If a job exceeds the timeout, the process is killed and the next cycle proceeds normally.
# Set a 5-minute timeout
claun -c "Big refactor" --timeout 300
# Disable timeout entirely
claun -c "Long-running task" --timeout 0
# Run once with a short timeout
claun --once -c "Quick check" --timeout 30
In the TUI, the timeout is editable via the "Timeout" input field. The timeout_seconds field is also saved/loaded from .claun.json config files.
Session Persistence
To resume a previous Claude Code session, use the --flags option to pass --resume:
# First, note your session ID from a previous run# Then resume it:
claun -c "Continue working on the feature" -f "--resume abc123-def456"# In the TUI, enter in the "Claude Flags" field:# --resume abc123-def456
You can also pass other claude flags:
# Use a specific model
claun -c "Pull and fix bugs from the Linear MCP, run /code-simplifier and push PRs" -f "--model opus"# Enable web search
claun -c "What is the score of the Niners/Seahawks game?" -f "--allowedTools WebSearch"# Combine multiple flags
claun -c "Fix the next bug on the bug list" -f "--resume abc123 --model sonnet"
CLI Options
Options:
-c, --command TEXT Claude Code command to run
-f, --flags TEXT Extra flags for claude (e.g., '--resume abc123')
-H, --headless Run in headless mode (no TUI)
-d, --days TEXT Days to run (mon,tue,wed,thu,fri,sat,sun)
--weekdays Run only on weekdays (mon-fri)
--weekends Run only on weekends (sat-sun)
--hours TEXT Hour range (e.g., '9-17' or '9am-5pm')
-m, --minutes [1|5|15|60] Minute interval
-t, --timeout INTEGER Timeout in seconds per job (default: 120, 0 to disable)
-l, --log-path PATH Directory for log files
--log-id TEXT Optional ID prefix for log filenames
-P, --paused Start in paused state
--once Run once immediately and exit
--dry-run Show schedule without executing
-v, --version Show version

Subcommands
Browse Logs
# List recent logs in current directory
claun logs
# List logs from specific path
claun logs --path /var/log/claun
# Limit to 10 most recent
claun logs -n 10
Log Files
Logs are saved as: [log_id_]claun_YYYYMMDD_HHMMSS_microseconds.txt
Examples:
  • claun_20260112_143022_123456.txt
  • myproject_claun_20260112_143022_789012.txt (with --log-id)
License
GPL-3.0
About
Use claun to run Claude Code jobs on timers. Sometimes systemd is just overkill.
Resources
Readme
GPL-3.0 license
Activity
Stars
8 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - nsmith/claun: Use claun to run Claude Code jobs on timers. Sometimes systemd is just overkill. · GitHub
Skip to content
BranchesTags
Repository files navigation
claun
Note: Claude Code now has a similar feature! You should probably just use /loop!
Claun TUI
Schedule Claude Code jobs with a TUI or headless mode. Sometimes systemd is just overkill. Pronounced "Klon" like the guitar pedal.
In all seriousness, the purpose of this tool is to quickly prototype workflows, or for something that is going to run on your dev desktop (like pulling/fixing bugs and submitting PRs). Please don't use it for a production pipeline! If you want to build something that you can rely on, please use systemd or Kinesis/Glue/Lambda (or I guess cron if you are old school like that). I am not responsible for any 3am pages when this falls over ;)
Installation
pip install claun-tui
Quick Start
# Launch TUI (default)
claun
# Launch TUI with pre-filled command
claun -c "Review our metrics from the past hour for anomalies"# Run in headless mode
claun -H -c "Update bug list from Linear MCP and fix" -m 60
# See what would run without executing
claun --dry-run -c "test command"
Features
  • Simple TUI: Single-page interface with all controls visible - no menu diving
  • Headless mode: Run as a background service with terminal output
  • Flexible scheduling: Days of week, hour ranges, minute intervals
  • Job timeout: Configurable timeout kills stuck processes (default: 120s)
  • Claude flags: Pass any flags to claude (like --resume for session persistence)
  • Simple logging: Automatic log files with browseable history
TUI Mode
Launch with claun to get an interactive interface with:
  • Command input field
  • Optional Claude flags (e.g., --resume <session-id> or --model sonnet)
  • Timeout setting (seconds, 0 to disable)
  • Day-of-week toggles (M T W T F S S)
  • Minute interval selector (1, 5, 15, or 60 minutes)
  • Big countdown clock to next run
  • Pause/Resume control
  • Live output log
Keyboard shortcuts:
  • q - Quit
  • p - Pause/Resume
  • r - Run now
  • c - Clear log
Headless Mode
Run without TUI for background/automated use:
# Every 15 minutes (default)
claun -H -c "Check for issues"# Hourly during work hours
claun -H -c "Status update" --hours "9am-5pm" -m 60
# Weekdays only
claun -H -c "Daily standup" --weekdays -m 60
Job Timeout
Jobs have a default timeout of 120 seconds. If a job exceeds the timeout, the process is killed and the next cycle proceeds normally.
# Set a 5-minute timeout
claun -c "Big refactor" --timeout 300
# Disable timeout entirely
claun -c "Long-running task" --timeout 0
# Run once with a short timeout
claun --once -c "Quick check" --timeout 30
In the TUI, the timeout is editable via the "Timeout" input field. The timeout_seconds field is also saved/loaded from .claun.json config files.
Session Persistence
To resume a previous Claude Code session, use the --flags option to pass --resume:
# First, note your session ID from a previous run# Then resume it:
claun -c "Continue working on the feature" -f "--resume abc123-def456"# In the TUI, enter in the "Claude Flags" field:# --resume abc123-def456
You can also pass other claude flags:
# Use a specific model
claun -c "Pull and fix bugs from the Linear MCP, run /code-simplifier and push PRs" -f "--model opus"# Enable web search
claun -c "What is the score of the Niners/Seahawks game?" -f "--allowedTools WebSearch"# Combine multiple flags
claun -c "Fix the next bug on the bug list" -f "--resume abc123 --model sonnet"
CLI Options
Options:
-c, --command TEXT Claude Code command to run
-f, --flags TEXT Extra flags for claude (e.g., '--resume abc123')
-H, --headless Run in headless mode (no TUI)
-d, --days TEXT Days to run (mon,tue,wed,thu,fri,sat,sun)
--weekdays Run only on weekdays (mon-fri)
--weekends Run only on weekends (sat-sun)
--hours TEXT Hour range (e.g., '9-17' or '9am-5pm')
-m, --minutes [1|5|15|60] Minute interval
-t, --timeout INTEGER Timeout in seconds per job (default: 120, 0 to disable)
-l, --log-path PATH Directory for log files
--log-id TEXT Optional ID prefix for log filenames
-P, --paused Start in paused state
--once Run once immediately and exit
--dry-run Show schedule without executing
-v, --version Show version

Subcommands
Browse Logs
# List recent logs in current directory
claun logs
# List logs from specific path
claun logs --path /var/log/claun
# Limit to 10 most recent
claun logs -n 10
Log Files
Logs are saved as: [log_id_]claun_YYYYMMDD_HHMMSS_microseconds.txt
Examples:
  • claun_20260112_143022_123456.txt
  • myproject_claun_20260112_143022_789012.txt (with --log-id)
License
GPL-3.0
About
Use claun to run Claude Code jobs on timers. Sometimes systemd is just overkill.
Resources
Readme
GPL-3.0 license
Activity
Stars
8 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - nsmith/claun: Use claun to run Claude Code jobs on timers. Sometimes systemd is just overkill. · GitHub
Skip to content
BranchesTags
Repository files navigation
claun
Note: Claude Code now has a similar feature! You should probably just use /loop!
Claun TUI
Schedule Claude Code jobs with a TUI or headless mode. Sometimes systemd is just overkill. Pronounced "Klon" like the guitar pedal.
In all seriousness, the purpose of this tool is to quickly prototype workflows, or for something that is going to run on your dev desktop (like pulling/fixing bugs and submitting PRs). Please don't use it for a production pipeline! If you want to build something that you can rely on, please use systemd or Kinesis/Glue/Lambda (or I guess cron if you are old school like that). I am not responsible for any 3am pages when this falls over ;)
Installation
pip install claun-tui
Quick Start
# Launch TUI (default)
claun
# Launch TUI with pre-filled command
claun -c "Review our metrics from the past hour for anomalies"# Run in headless mode
claun -H -c "Update bug list from Linear MCP and fix" -m 60
# See what would run without executing
claun --dry-run -c "test command"
Features
  • Simple TUI: Single-page interface with all controls visible - no menu diving
  • Headless mode: Run as a background service with terminal output
  • Flexible scheduling: Days of week, hour ranges, minute intervals
  • Job timeout: Configurable timeout kills stuck processes (default: 120s)
  • Claude flags: Pass any flags to claude (like --resume for session persistence)
  • Simple logging: Automatic log files with browseable history
TUI Mode
Launch with claun to get an interactive interface with:
  • Command input field
  • Optional Claude flags (e.g., --resume <session-id> or --model sonnet)
  • Timeout setting (seconds, 0 to disable)
  • Day-of-week toggles (M T W T F S S)
  • Minute interval selector (1, 5, 15, or 60 minutes)
  • Big countdown clock to next run
  • Pause/Resume control
  • Live output log
Keyboard shortcuts:
  • q - Quit
  • p - Pause/Resume
  • r - Run now
  • c - Clear log
Headless Mode
Run without TUI for background/automated use:
# Every 15 minutes (default)
claun -H -c "Check for issues"# Hourly during work hours
claun -H -c "Status update" --hours "9am-5pm" -m 60
# Weekdays only
claun -H -c "Daily standup" --weekdays -m 60
Job Timeout
Jobs have a default timeout of 120 seconds. If a job exceeds the timeout, the process is killed and the next cycle proceeds normally.
# Set a 5-minute timeout
claun -c "Big refactor" --timeout 300
# Disable timeout entirely
claun -c "Long-running task" --timeout 0
# Run once with a short timeout
claun --once -c "Quick check" --timeout 30
In the TUI, the timeout is editable via the "Timeout" input field. The timeout_seconds field is also saved/loaded from .claun.json config files.
Session Persistence
To resume a previous Claude Code session, use the --flags option to pass --resume:
# First, note your session ID from a previous run# Then resume it:
claun -c "Continue working on the feature" -f "--resume abc123-def456"# In the TUI, enter in the "Claude Flags" field:# --resume abc123-def456
You can also pass other claude flags:
# Use a specific model
claun -c "Pull and fix bugs from the Linear MCP, run /code-simplifier and push PRs" -f "--model opus"# Enable web search
claun -c "What is the score of the Niners/Seahawks game?" -f "--allowedTools WebSearch"# Combine multiple flags
claun -c "Fix the next bug on the bug list" -f "--resume abc123 --model sonnet"
CLI Options
Options:
-c, --command TEXT Claude Code command to run
-f, --flags TEXT Extra flags for claude (e.g., '--resume abc123')
-H, --headless Run in headless mode (no TUI)
-d, --days TEXT Days to run (mon,tue,wed,thu,fri,sat,sun)
--weekdays Run only on weekdays (mon-fri)
--weekends Run only on weekends (sat-sun)
--hours TEXT Hour range (e.g., '9-17' or '9am-5pm')
-m, --minutes [1|5|15|60] Minute interval
-t, --timeout INTEGER Timeout in seconds per job (default: 120, 0 to disable)
-l, --log-path PATH Directory for log files
--log-id TEXT Optional ID prefix for log filenames
-P, --paused Start in paused state
--once Run once immediately and exit
--dry-run Show schedule without executing
-v, --version Show version

Subcommands
Browse Logs
# List recent logs in current directory
claun logs
# List logs from specific path
claun logs --path /var/log/claun
# Limit to 10 most recent
claun logs -n 10
Log Files
Logs are saved as: [log_id_]claun_YYYYMMDD_HHMMSS_microseconds.txt
Examples:
  • claun_20260112_143022_123456.txt
  • myproject_claun_20260112_143022_789012.txt (with --log-id)
License
GPL-3.0
About
Use claun to run Claude Code jobs on timers. Sometimes systemd is just overkill.
Resources
Readme
GPL-3.0 license
Activity
Stars
8 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - nsmith/claun: Use claun to run Claude Code jobs on timers. Sometimes systemd is just overkill. · GitHub
Skip to content
BranchesTags
Repository files navigation
claun
Note: Claude Code now has a similar feature! You should probably just use /loop!
Claun TUI
Schedule Claude Code jobs with a TUI or headless mode. Sometimes systemd is just overkill. Pronounced "Klon" like the guitar pedal.
In all seriousness, the purpose of this tool is to quickly prototype workflows, or for something that is going to run on your dev desktop (like pulling/fixing bugs and submitting PRs). Please don't use it for a production pipeline! If you want to build something that you can rely on, please use systemd or Kinesis/Glue/Lambda (or I guess cron if you are old school like that). I am not responsible for any 3am pages when this falls over ;)
Installation
pip install claun-tui
Quick Start
# Launch TUI (default)
claun
# Launch TUI with pre-filled command
claun -c "Review our metrics from the past hour for anomalies"# Run in headless mode
claun -H -c "Update bug list from Linear MCP and fix" -m 60
# See what would run without executing
claun --dry-run -c "test command"
Features
  • Simple TUI: Single-page interface with all controls visible - no menu diving
  • Headless mode: Run as a background service with terminal output
  • Flexible scheduling: Days of week, hour ranges, minute intervals
  • Job timeout: Configurable timeout kills stuck processes (default: 120s)
  • Claude flags: Pass any flags to claude (like --resume for session persistence)
  • Simple logging: Automatic log files with browseable history
TUI Mode
Launch with claun to get an interactive interface with:
  • Command input field
  • Optional Claude flags (e.g., --resume <session-id> or --model sonnet)
  • Timeout setting (seconds, 0 to disable)
  • Day-of-week toggles (M T W T F S S)
  • Minute interval selector (1, 5, 15, or 60 minutes)
  • Big countdown clock to next run
  • Pause/Resume control
  • Live output log
Keyboard shortcuts:
  • q - Quit
  • p - Pause/Resume
  • r - Run now
  • c - Clear log
Headless Mode
Run without TUI for background/automated use:
# Every 15 minutes (default)
claun -H -c "Check for issues"# Hourly during work hours
claun -H -c "Status update" --hours "9am-5pm" -m 60
# Weekdays only
claun -H -c "Daily standup" --weekdays -m 60
Job Timeout
Jobs have a default timeout of 120 seconds. If a job exceeds the timeout, the process is killed and the next cycle proceeds normally.
# Set a 5-minute timeout
claun -c "Big refactor" --timeout 300
# Disable timeout entirely
claun -c "Long-running task" --timeout 0
# Run once with a short timeout
claun --once -c "Quick check" --timeout 30
In the TUI, the timeout is editable via the "Timeout" input field. The timeout_seconds field is also saved/loaded from .claun.json config files.
Session Persistence
To resume a previous Claude Code session, use the --flags option to pass --resume:
# First, note your session ID from a previous run# Then resume it:
claun -c "Continue working on the feature" -f "--resume abc123-def456"# In the TUI, enter in the "Claude Flags" field:# --resume abc123-def456
You can also pass other claude flags:
# Use a specific model
claun -c "Pull and fix bugs from the Linear MCP, run /code-simplifier and push PRs" -f "--model opus"# Enable web search
claun -c "What is the score of the Niners/Seahawks game?" -f "--allowedTools WebSearch"# Combine multiple flags
claun -c "Fix the next bug on the bug list" -f "--resume abc123 --model sonnet"
CLI Options
Options:
-c, --command TEXT Claude Code command to run
-f, --flags TEXT Extra flags for claude (e.g., '--resume abc123')
-H, --headless Run in headless mode (no TUI)
-d, --days TEXT Days to run (mon,tue,wed,thu,fri,sat,sun)
--weekdays Run only on weekdays (mon-fri)
--weekends Run only on weekends (sat-sun)
--hours TEXT Hour range (e.g., '9-17' or '9am-5pm')
-m, --minutes [1|5|15|60] Minute interval
-t, --timeout INTEGER Timeout in seconds per job (default: 120, 0 to disable)
-l, --log-path PATH Directory for log files
--log-id TEXT Optional ID prefix for log filenames
-P, --paused Start in paused state
--once Run once immediately and exit
--dry-run Show schedule without executing
-v, --version Show version

Subcommands
Browse Logs
# List recent logs in current directory
claun logs
# List logs from specific path
claun logs --path /var/log/claun
# Limit to 10 most recent
claun logs -n 10
Log Files
Logs are saved as: [log_id_]claun_YYYYMMDD_HHMMSS_microseconds.txt
Examples:
  • claun_20260112_143022_123456.txt
  • myproject_claun_20260112_143022_789012.txt (with --log-id)
License
GPL-3.0
About
Use claun to run Claude Code jobs on timers. Sometimes systemd is just overkill.
Resources
Readme
GPL-3.0 license
Activity
Stars
8 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages