claude-resume-hub 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ibrahim Kalemci
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,104 @@
+<h1 align="center">⏰ claude-resume-hub</h1>
+
+<p align="center">
+  <b>Stop babysitting Claude Code usage limits.</b><br>
+  Hit a limit at 2am? <b>Wake up to finished work.</b>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/claude-resume-hub"><img src="https://img.shields.io/npm/v/claude-resume-hub?color=c96442" alt="npm"></a>
+  <img src="https://img.shields.io/badge/node-%3E%3D16-3fb950" alt="node >= 16">
+  <img src="https://img.shields.io/badge/Windows%20%7C%20macOS%20%7C%20Linux-8b93a7" alt="platforms">
+  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue" alt="MIT"></a>
+</p>
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/IbrahimKalemci/claude-resume-hub/main/docs/dashboard.svg" alt="live dashboard with a big countdown, status and streaming log" width="620">
+</p>
+
+<p align="center"><b>🇬🇧 <a href="#-english">English</a> &nbsp;·&nbsp; 🇹🇷 <a href="#-türkçe">Türkçe</a></b></p>
+
+---
+
+## 🇬🇧 English
+
+Claude Code hits your limit and just… **stops** — until you come back and type `continue`.
+**claude-resume-hub** waits for the exact reset time and continues **for you**, then pings your desktop when it's rolling again. One command, zero setup, every OS.
+
+### Install & run — 3 steps
+
+**1.** Make sure Claude Code works (open a terminal, type `claude --version`). Don't have it? [Get it here](https://docs.claude.com/en/docs/claude-code).
+
+**2.** Go to your project folder and run:
+
+```bash
+npx claude-resume-hub --web
+```
+
+**3.** A dashboard opens in your browser — click **“Enable alerts”**, then walk away. 🎉
+
+That's it. No install, no config. It works on **Windows, macOS and Linux**.
+
+### Why you'll love it
+
+- ⏱️ **Exact countdown** — reads the real reset time, not a guess
+- 🔔 **Desktop alerts** — close the terminal, go live your life
+- 🖥️ **Beautiful live dashboard** — countdown, status, and a streaming log
+- 🪶 **Zero dependencies**, 100% local — nothing leaves your machine
+
+### Handy commands
+
+```bash
+npx claude-resume-hub              # no dashboard, just auto-resume
+npx claude-resume-hub --web        # with dashboard + alerts
+npx claude-resume-hub -t "run all tests and fix failures"   # start a task
+npx claude-resume-hub --help       # all options
+```
+
+Prefer a permanent command? `npm i -g claude-resume-hub` gives you `crh --web`.
+
+---
+
+## 🇹🇷 Türkçe
+
+Claude Code limitine takılınca **durur** — sen gelip `continue` yazana kadar bekler.
+**claude-resume-hub** limitin tam açılma saatini bekleyip **senin yerine** devam eder, iş yeniden başlayınca da masaüstüne bildirim atar. Tek komut, sıfır ayar, her işletim sistemi.
+
+### Kurulum & çalıştırma — 3 adım
+
+**1.** Claude Code çalışıyor mu bak (terminal aç, `claude --version` yaz). Yoksa [buradan kur](https://docs.claude.com/en/docs/claude-code).
+
+**2.** Projenin klasörüne gir ve şunu çalıştır:
+
+```bash
+npx claude-resume-hub --web
+```
+
+**3.** Tarayıcıda bir panel açılır — **“Enable alerts”**e bas ve arkana yaslan. 🎉
+
+Hepsi bu. Kurulum yok, ayar yok. **Windows, macOS ve Linux**'ta çalışır.
+
+### Neden bayılacaksın
+
+- ⏱️ **Net geri sayım** — tahmin değil, gerçek reset saatini okur
+- 🔔 **Masaüstü bildirimi** — terminali kapat, hayatına dön
+- 🖥️ **Şık canlı panel** — geri sayım, durum ve canlı log
+- 🪶 **Sıfır bağımlılık**, %100 yerel — hiçbir veri makineden çıkmaz
+
+### İşine yarayacak komutlar
+
+```bash
+npx claude-resume-hub              # panelsiz, sadece otomatik devam
+npx claude-resume-hub --web        # panel + bildirim
+npx claude-resume-hub -t "tüm testleri çalıştır ve hataları düzelt"   # görev başlat
+npx claude-resume-hub --help       # tüm seçenekler
+```
+
+Kalıcı komut ister misin? `npm i -g claude-resume-hub` sana `crh --web` verir.
+
+---
+
+<p align="center">
+  Made for everyone who's tired of waiting on the reset clock.<br>
+  <b>MIT</b> © Ibrahim Kalemci · <a href="CHANGELOG.md">Changelog</a>
+</p>

package/bin/cli.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * claude-auto-resume — run Claude Code and auto-continue the moment a usage/
+ * session limit resets. Optional live dashboard with desktop notifications.
+ *
+ * Zero dependencies. Windows / macOS / Linux.
+ */
+
+const { AutoResumeEngine } = require("../lib/engine");
+const { startDashboard } = require("../lib/dashboard");
+const VERSION = require("../package.json").version;
+
+function parseArgs(argv) {
+  const opts = {
+    prompt: "continue",
+    task: null,
+    dir: process.cwd(),
+    buffer: 30,
+    poll: 5,
+    maxCycles: 100,
+    verbose: false,
+    web: false,
+    port: 4177,
+    open: true,
+    passthrough: [],
+  };
+  const args = [...argv];
+  const sep = args.indexOf("--");
+  if (sep !== -1) { opts.passthrough = args.splice(sep + 1); args.splice(sep, 1); }
+
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    const next = () => args[++i];
+    switch (a) {
+      case "-p": case "--prompt": opts.prompt = next(); break;
+      case "-t": case "--task": opts.task = next(); break;
+      case "-d": case "--dir": opts.dir = next(); break;
+      case "-b": case "--buffer": opts.buffer = parseInt(next(), 10); break;
+      case "--poll": opts.poll = parseInt(next(), 10); break;
+      case "-m": case "--max-cycles": opts.maxCycles = parseInt(next(), 10); break;
+      case "-w": case "--web": opts.web = true; break;
+      case "--port": opts.port = parseInt(next(), 10); break;
+      case "--no-open": opts.open = false; break;
+      case "--verbose": opts.verbose = true; break;
+      case "-h": case "--help": printHelp(); process.exit(0);
+      case "-v": case "--version": console.log(VERSION); process.exit(0);
+      default:
+        console.error(`Unknown option: ${a}\nRun with --help for usage.`);
+        process.exit(2);
+    }
+  }
+  return opts;
+}
+
+function printHelp() {
+  console.log(`
+claude-resume-hub v${VERSION}
+
+Run Claude Code and auto-continue the moment a usage/session limit resets.
+
+USAGE
+  claude-resume-hub [options] [-- <extra claude args>]
+
+OPTIONS
+  -p, --prompt <text>     Message sent to continue after a reset (default: "continue")
+  -t, --task <text>       Initial task; starts a fresh session on the first run,
+                          then continues it. Omit to attach to the most recent session.
+  -d, --dir <path>        Working directory / project (default: current dir)
+  -b, --buffer <seconds>  Safety margin added after the reset time (default: 30)
+      --poll <minutes>    Retry interval if a reset time can't be determined (default: 5)
+  -m, --max-cycles <n>    Max limit->wait->continue cycles (default: 100)
+  -w, --web               Open a live dashboard (countdown + desktop alerts)
+      --port <n>          Dashboard port (default: 4177)
+      --no-open           Don't auto-open the browser for the dashboard
+      --verbose           Print detection diagnostics
+  -h, --help              Show this help
+  -v, --version           Show version
+
+EXAMPLES
+  claude-resume-hub                 # keep the latest session going across resets
+  claude-resume-hub --web           # ...with a live dashboard + desktop alerts
+  claude-resume-hub -t "run all the tests and fix failures"
+  claude-resume-hub -- --model opus # forward flags to claude
+`);
+}
+
+const C = { cyan: "\x1b[36m", dim: "\x1b[2m", green: "\x1b[32m", yellow: "\x1b[33m", red: "\x1b[31m", reset: "\x1b[0m" };
+const stamp = () => new Date().toLocaleString();
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  const engine = new AutoResumeEngine(opts);
+
+  // Colorize a few known log lines for the terminal.
+  engine.on("log", (line) => {
+    let color = C.cyan;
+    if (/^Done|complete/i.test(line)) color = C.green;
+    else if (/limit hit|Waiting|Retrying/i.test(line)) color = C.yellow;
+    else if (/not found|error|Stopping/i.test(line)) color = C.red;
+    console.log(`${color}[auto-resume ${stamp()}]${C.reset} ${line}`);
+  });
+  engine.on("output", (chunk) => process.stdout.write(chunk));
+
+  if (opts.web) {
+    const { url, error } = await startDashboard(engine, { port: opts.port, open: opts.open });
+    if (url) console.log(`${C.green}[auto-resume]${C.reset} Dashboard: ${url}  (leave it open for desktop alerts)`);
+    else console.log(`${C.red}[auto-resume]${C.reset} Could not start dashboard: ${error && error.message}`);
+  }
+
+  process.on("SIGINT", () => { console.log("\n[auto-resume] Interrupted. Bye."); engine.stop(); process.exit(130); });
+
+  const result = await engine.run();
+  // Keep the process (and dashboard) alive briefly so the browser sees the final state.
+  if (opts.web) setTimeout(() => process.exit(result.code), 1500);
+  else process.exit(result.code);
+}
+
+main().catch((err) => { console.error("[auto-resume] Fatal:", err); process.exit(1); });

package/lib/dashboard.js

@@ -0,0 +1,207 @@
+"use strict";
+
+const http = require("http");
+const { spawn } = require("child_process");
+
+/**
+ * Zero-dependency live dashboard for the auto-resume engine.
+ * Serves a single page on localhost that shows a live countdown, current
+ * status, streaming logs, and fires a desktop notification (via the browser
+ * Notification API) when the limit resets or the task finishes.
+ *
+ * Communicates with the browser over Server-Sent Events — no client libs.
+ */
+function startDashboard(engine, { port = 4177, open = true } = {}) {
+  const logs = [];
+  const clients = new Set();
+
+  const push = (event, data) => {
+    const chunk = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+    for (const res of clients) res.write(chunk);
+  };
+
+  engine.on("state", (s) => push("state", s));
+  engine.on("log", (line) => {
+    const entry = { t: new Date().toLocaleTimeString(), line };
+    logs.push(entry);
+    if (logs.length > 300) logs.shift();
+    push("log", entry);
+  });
+
+  const server = http.createServer((req, res) => {
+    if (req.url === "/events") {
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+      });
+      res.write("retry: 2000\n\n");
+      // Snapshot for late joiners.
+      res.write(`event: state\ndata: ${JSON.stringify(engine.state)}\n\n`);
+      for (const e of logs) res.write(`event: log\ndata: ${JSON.stringify(e)}\n\n`);
+      clients.add(res);
+      req.on("close", () => clients.delete(res));
+      return;
+    }
+    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+    res.end(PAGE);
+  });
+
+  return new Promise((resolve) => {
+    const tryListen = (p, attempts) => {
+      server.once("error", (err) => {
+        if (err.code === "EADDRINUSE" && attempts > 0) return tryListen(p + 1, attempts - 1);
+        resolve({ url: null, close: () => server.close(), error: err });
+      });
+      server.listen(p, "127.0.0.1", () => {
+        const url = `http://127.0.0.1:${p}`;
+        if (open) openBrowser(url);
+        resolve({ url, close: () => server.close() });
+      });
+    };
+    tryListen(port, 15);
+  });
+}
+
+function openBrowser(url) {
+  try {
+    const cmd =
+      process.platform === "win32" ? "cmd" :
+      process.platform === "darwin" ? "open" : "xdg-open";
+    const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+    spawn(cmd, args, { stdio: "ignore", detached: true }).unref();
+  } catch {}
+}
+
+const PAGE = `<!doctype html>
+<html lang="en"><head>
+<meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<title>claude-auto-resume</title>
+<style>
+  :root { --bg:#0b0e14; --panel:#131826; --line:#232a3d; --txt:#e6e9f0; --dim:#8b93a7;
+          --accent:#c96442; --ok:#3fb950; --warn:#d29922; --err:#f85149; }
+  * { box-sizing:border-box; }
+  body { margin:0; font-family:ui-sans-serif,system-ui,-apple-system,Segoe UI,Roboto,sans-serif;
+         background:radial-gradient(1200px 600px at 50% -10%, #16203a 0%, var(--bg) 60%); color:var(--txt); min-height:100vh; }
+  .wrap { max-width:760px; margin:0 auto; padding:28px 20px 40px; }
+  header { display:flex; align-items:center; justify-content:space-between; gap:12px; margin-bottom:22px; }
+  .brand { display:flex; align-items:center; gap:10px; font-weight:700; letter-spacing:.2px; }
+  .dot { width:10px; height:10px; border-radius:50%; background:var(--accent); box-shadow:0 0 12px var(--accent); }
+  .pill { font-size:12px; font-weight:600; padding:5px 11px; border-radius:999px; border:1px solid var(--line); color:var(--dim); }
+  .pill.running { color:var(--accent); border-color:var(--accent); }
+  .pill.waiting { color:var(--warn); border-color:var(--warn); }
+  .pill.done { color:var(--ok); border-color:var(--ok); }
+  .pill.error { color:var(--err); border-color:var(--err); }
+  .card { background:linear-gradient(180deg, var(--panel), #0f1420); border:1px solid var(--line);
+          border-radius:18px; padding:34px 26px; text-align:center; box-shadow:0 20px 60px rgba(0,0,0,.35); }
+  .label { font-size:13px; text-transform:uppercase; letter-spacing:1.5px; color:var(--dim); margin-bottom:10px; }
+  .timer { font-variant-numeric:tabular-nums; font-weight:800; font-size:clamp(48px,12vw,88px); line-height:1;
+           font-family:ui-monospace,SFMono-Regular,Menlo,monospace; }
+  .msg { margin-top:14px; color:var(--dim); min-height:20px; }
+  .meta { display:flex; gap:22px; justify-content:center; flex-wrap:wrap; margin-top:22px; color:var(--dim); font-size:13px; }
+  .meta b { color:var(--txt); font-weight:600; }
+  .pulse { animation:pulse 1.6s ease-in-out infinite; }
+  @keyframes pulse { 0%,100%{opacity:1} 50%{opacity:.45} }
+  .row { display:flex; align-items:center; justify-content:space-between; margin:22px 2px 8px; }
+  .row h2 { font-size:13px; text-transform:uppercase; letter-spacing:1.2px; color:var(--dim); margin:0; }
+  button { background:var(--accent); color:#fff; border:0; border-radius:9px; padding:8px 14px; font-weight:600;
+           font-size:13px; cursor:pointer; }
+  button.ghost { background:transparent; color:var(--dim); border:1px solid var(--line); }
+  #log { background:#0a0d15; border:1px solid var(--line); border-radius:12px; padding:14px; height:230px; overflow:auto;
+         font-family:ui-monospace,SFMono-Regular,Menlo,monospace; font-size:12.5px; line-height:1.6; }
+  #log div { white-space:pre-wrap; word-break:break-word; }
+  #log .t { color:var(--dim); margin-right:8px; }
+  footer { text-align:center; color:var(--dim); font-size:12px; margin-top:20px; }
+  a { color:var(--accent); }
+</style></head>
+<body><div class="wrap">
+  <header>
+    <div class="brand"><span class="dot" id="dot"></span> claude-auto-resume</div>
+    <div style="display:flex; gap:8px; align-items:center;">
+      <span class="pill" id="pill">connecting…</span>
+      <button class="ghost" id="notifyBtn">🔔 Enable alerts</button>
+    </div>
+  </header>
+
+  <div class="card">
+    <div class="label" id="cardLabel">Status</div>
+    <div class="timer" id="timer">—</div>
+    <div class="msg" id="msg">Waiting for engine…</div>
+    <div class="meta">
+      <div>Cycle <b id="cycle">–</b></div>
+      <div>Resets at <b id="resetAt">–</b></div>
+    </div>
+  </div>
+
+  <div class="row"><h2>Live log</h2><button class="ghost" id="clearBtn">clear</button></div>
+  <div id="log"></div>
+
+  <footer>Running locally · leave this tab open so alerts can fire · <a href="https://github.com/IbrahimKalemci/claude-resume-hub" target="_blank">github</a></footer>
+</div>
+<script>
+  const $ = (id) => document.getElementById(id);
+  let state = { phase: "starting" }, wakeAt = null, lastPhase = null;
+
+  function fmt(ms){ ms=Math.max(0,ms); const s=Math.floor(ms/1000);
+    const h=Math.floor(s/3600),m=Math.floor((s%3600)/60),x=s%60;
+    return String(h).padStart(2,'0')+':'+String(m).padStart(2,'0')+':'+String(x).padStart(2,'0'); }
+
+  function render(){
+    const p = state.phase || "starting";
+    $("pill").className = "pill " + p;
+    $("pill").textContent = p;
+    $("dot").style.background = getComputedStyle(document.documentElement)
+      .getPropertyValue(p==="done"?"--ok":p==="error"?"--err":p==="waiting"?"--warn":"--accent");
+    $("cycle").textContent = state.cycle ? (state.cycle + " / " + state.maxCycles) : "–";
+    $("resetAt").textContent = state.resetAt ? new Date(state.resetAt).toLocaleTimeString() : "–";
+    $("msg").textContent = state.message || "";
+    const t = $("timer"); t.classList.remove("pulse");
+    if (p === "waiting" && wakeAt) { $("cardLabel").textContent = "Resuming in"; t.textContent = fmt(wakeAt - Date.now()); }
+    else if (p === "running") { $("cardLabel").textContent = "Status"; t.textContent = "▶"; t.classList.add("pulse"); }
+    else if (p === "done") { $("cardLabel").textContent = "Status"; t.textContent = "✓"; }
+    else if (p === "error") { $("cardLabel").textContent = "Status"; t.textContent = "✕"; }
+    else { $("cardLabel").textContent = "Status"; t.textContent = "…"; }
+  }
+
+  function notify(title, body){
+    try { if (window.Notification && Notification.permission === "granted") new Notification(title, { body }); } catch {}
+  }
+  function beep(){ try { const a=new (window.AudioContext||window.webkitAudioContext)();
+    const o=a.createOscillator(), g=a.createGain(); o.connect(g); g.connect(a.destination);
+    o.frequency.value=660; g.gain.value=.05; o.start(); setTimeout(()=>{o.stop();a.close();},180);} catch {} }
+
+  function onPhaseChange(prev, cur){
+    if (cur === "waiting") notify("⏳ Usage limit hit", state.message || "Waiting for reset");
+    if (cur === "running" && prev === "waiting") { notify("▶ Limit reset — resumed!", "Claude is continuing your task."); beep(); }
+    if (cur === "done") { notify("✅ Task complete", state.message || "All done."); beep(); }
+    if (cur === "error") notify("⚠ Stopped", state.message || "An error occurred.");
+  }
+
+  const es = new EventSource("/events");
+  es.addEventListener("state", (e) => {
+    const prev = lastPhase; state = JSON.parse(e.data);
+    wakeAt = state.wakeAt ? new Date(state.wakeAt).getTime() : null;
+    if (state.phase !== prev) { onPhaseChange(prev, state.phase); lastPhase = state.phase; }
+    render();
+  });
+  es.addEventListener("log", (e) => {
+    const { t, line } = JSON.parse(e.data);
+    const d = document.createElement("div");
+    d.innerHTML = '<span class="t">' + t + '</span>';
+    d.appendChild(document.createTextNode(line));
+    const box = $("log"); box.appendChild(d); box.scrollTop = box.scrollHeight;
+  });
+
+  $("notifyBtn").onclick = () => { if (window.Notification) Notification.requestPermission().then(p => {
+    $("notifyBtn").textContent = p === "granted" ? "🔔 Alerts on" : "🔕 Alerts blocked"; }); };
+  $("clearBtn").onclick = () => { $("log").innerHTML = ""; };
+
+  setInterval(() => { if (state.phase === "waiting" && wakeAt) $("timer").textContent = fmt(wakeAt - Date.now()); }, 1000);
+  render();
+  // Notifications are enabled explicitly via the "Enable alerts" button
+  // (browsers discourage auto-prompting on load).
+  if (window.Notification && Notification.permission === "granted") $("notifyBtn").textContent = "🔔 Alerts on";
+</script>
+</body></html>`;
+
+module.exports = { startDashboard };

package/lib/detect.js

@@ -0,0 +1,76 @@
+"use strict";
+
+/**
+ * Usage-limit detection for Claude Code output.
+ *
+ * Detection priority:
+ *   1. Machine-readable marker "Claude AI usage limit reached|<unix_ts>"
+ *      -> exact, timezone-proof reset time.
+ *   2. Human prose "…resets 3:45pm" / "reset at 2pm" / "resets Mon 12:00am".
+ *   3. A limit phrase with no time -> caller falls back to polling.
+ */
+
+/** Inspect combined stdout+stderr. Returns { hit, resetAt: Date|null, source }. */
+function detectLimit(text) {
+  if (!text) return { hit: false };
+
+  // 1) Machine-readable marker (seconds or milliseconds epoch).
+  const marker = text.match(/Claude AI usage limit reached\s*\|\s*(\d{10,13})/i);
+  if (marker) {
+    let n = parseInt(marker[1], 10);
+    if (n < 1e12) n *= 1000; // seconds -> ms
+    return { hit: true, resetAt: new Date(n), source: "epoch marker" };
+  }
+
+  // 2) Prose limit phrase, optionally with a clock time.
+  if (/hit your.*limit|usage limit reached|reached your.*limit|limit .*(reset|reached)/i.test(text)) {
+    const t = parseClockTime(text);
+    return { hit: true, resetAt: t, source: t ? "prose time" : "prose (no time)" };
+  }
+
+  return { hit: false };
+}
+
+/**
+ * Parse a human reset time such as "resets 3:45pm", "reset at 2pm",
+ * "resets Mon 12:00am". Best-effort fallback; the epoch marker is authoritative.
+ * Returns a Date (local) or null.
+ */
+function parseClockTime(text) {
+  const m = text.match(
+    /reset(?:s|\s+at)?\s+(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)/i
+  );
+  if (!m) return null;
+
+  const day = m[1];
+  let h = parseInt(m[2], 10);
+  const min = m[3] ? parseInt(m[3], 10) : 0;
+  const ap = m[4].toLowerCase();
+  if (ap === "pm" && h < 12) h += 12;
+  if (ap === "am" && h === 12) h = 0;
+
+  const now = new Date();
+  const target = new Date(now);
+  target.setHours(h, min, 0, 0);
+
+  if (day) {
+    const map = { Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6 };
+    const want = map[day.slice(0, 3)];
+    while (target.getDay() !== want || target <= now) {
+      target.setDate(target.getDate() + 1);
+    }
+  } else if (target <= now) {
+    // Session windows are only a few hours long, never a full day.
+    if (now - target <= 15 * 60 * 1000) return now; // just reset -> resume now
+    target.setDate(target.getDate() + 1); // else it's a past-midnight time (tomorrow)
+  }
+  return target;
+}
+
+function fmtDuration(ms) {
+  const s = Math.max(0, Math.round(ms / 1000));
+  const h = Math.floor(s / 3600), m = Math.floor((s % 3600) / 60), sec = s % 60;
+  return [h ? `${h}h` : "", m ? `${m}m` : "", `${sec}s`].filter(Boolean).join(" ") || "0s";
+}
+
+module.exports = { detectLimit, parseClockTime, fmtDuration };

package/lib/engine.js

@@ -0,0 +1,146 @@
+"use strict";
+
+const { spawn } = require("child_process");
+const { EventEmitter } = require("events");
+const { detectLimit, fmtDuration } = require("./detect");
+
+/**
+ * AutoResumeEngine runs Claude Code in a loop, waiting out usage limits.
+ *
+ * Events:
+ *   "log"   (line)                        human-readable log line
+ *   "state" ({phase, cycle, maxCycles, resetAt, wakeAt, message})
+ *            phase ∈ starting|running|waiting|done|error
+ *   "output"(chunk)                       raw claude stdout/stderr passthrough
+ */
+class AutoResumeEngine extends EventEmitter {
+  constructor(opts) {
+    super();
+    this.opts = opts;
+    this.state = {
+      phase: "starting",
+      cycle: 0,
+      maxCycles: opts.maxCycles,
+      resetAt: null,
+      wakeAt: null,
+      message: "",
+    };
+    this._timer = null;
+    this._stopped = false;
+  }
+
+  _setState(patch) {
+    this.state = { ...this.state, ...patch };
+    this.emit("state", this.state);
+  }
+
+  log(line) {
+    this.emit("log", line);
+  }
+
+  quoteArg(s) {
+    s = String(s);
+    if (process.platform === "win32") return `"${s.replace(/"/g, '""')}"`;
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+  }
+
+  _runClaude(claudeArgs) {
+    return new Promise((resolve) => {
+      const cmd = ["claude", ...claudeArgs.map((a) => this.quoteArg(a))].join(" ");
+      const child = spawn(cmd, { cwd: this.opts.dir, shell: true, stdio: ["inherit", "pipe", "pipe"] });
+      this._child = child;
+
+      let output = "";
+      const tee = (stream) =>
+        stream.on("data", (d) => {
+          const s = d.toString();
+          output += s;
+          this.emit("output", s);
+        });
+      tee(child.stdout);
+      tee(child.stderr);
+
+      child.on("error", (err) => resolve({ code: -1, output, error: err }));
+      child.on("close", (code) => resolve({ code, output }));
+    });
+  }
+
+  _sleepUntil(wakeAt) {
+    return new Promise((resolve) => {
+      const tick = () => {
+        if (this._stopped) return resolve();
+        const remaining = wakeAt - new Date();
+        if (remaining <= 0) return resolve();
+        this.log(`Waiting ${fmtDuration(remaining)} — will resume at ${wakeAt.toLocaleTimeString()}`);
+        this._timer = setTimeout(tick, Math.min(remaining, 15 * 60 * 1000));
+      };
+      tick();
+    });
+  }
+
+  stop() {
+    this._stopped = true;
+    if (this._timer) clearTimeout(this._timer);
+    if (this._child) try { this._child.kill(); } catch {}
+  }
+
+  async run() {
+    const o = this.opts;
+    this.log(`Starting. dir="${o.dir}"  prompt="${o.prompt}"`);
+    if (o.task) this.log(`Initial task: "${o.task}"`);
+
+    for (let cycle = 1; cycle <= o.maxCycles && !this._stopped; cycle++) {
+      const claudeArgs =
+        cycle === 1 && o.task
+          ? ["-p", o.task, ...o.passthrough]
+          : ["-c", "-p", o.prompt, ...o.passthrough];
+
+      this._setState({ phase: "running", cycle, resetAt: null, wakeAt: null, message: "Running Claude…" });
+      this.log(`Cycle ${cycle}/${o.maxCycles} — running claude…`);
+
+      const { code, output, error } = await this._runClaude(claudeArgs);
+      if (this._stopped) break;
+
+      if (error && error.code === "ENOENT") {
+        this._setState({ phase: "error", message: "`claude` not found on PATH." });
+        this.log("`claude` not found on PATH. Install Claude Code: https://docs.claude.com/en/docs/claude-code");
+        return { ok: false, code: 127 };
+      }
+
+      const limit = detectLimit(output);
+      if (o.verbose) this.log(`detect: ${JSON.stringify({ code, ...limit })}`);
+
+      if (!limit.hit) {
+        if (code === 0) {
+          this._setState({ phase: "done", message: "Task complete — no limit hit." });
+          this.log("Done — no limit hit, task complete.");
+          return { ok: true, code: 0 };
+        }
+        this._setState({ phase: "error", message: `claude exited ${code} (not a limit error).` });
+        this.log(`claude exited with code ${code} and no usage-limit marker. Stopping (not a limit error).`);
+        return { ok: false, code: code === -1 ? 1 : code || 1 };
+      }
+
+      // Limit hit — schedule resume.
+      let wakeAt;
+      if (limit.resetAt) {
+        wakeAt = new Date(limit.resetAt.getTime() + o.buffer * 1000);
+        this._setState({ phase: "waiting", resetAt: limit.resetAt, wakeAt, message: `Limit hit — resuming at ${wakeAt.toLocaleTimeString()}` });
+        this.log(`Usage limit hit (via ${limit.source}). Resets ${limit.resetAt.toLocaleString()} — resuming at ${wakeAt.toLocaleTimeString()} (+${o.buffer}s).`);
+      } else {
+        wakeAt = new Date(Date.now() + o.poll * 60 * 1000);
+        this._setState({ phase: "waiting", resetAt: null, wakeAt, message: `Limit hit — retrying in ${o.poll} min` });
+        this.log(`Usage limit hit but reset time unknown (${limit.source}). Retrying in ${o.poll} min.`);
+      }
+      await this._sleepUntil(wakeAt);
+    }
+
+    if (!this._stopped) {
+      this._setState({ phase: "done", message: `Reached max cycles (${o.maxCycles}).` });
+      this.log(`Reached max cycles (${o.maxCycles}). Stopping.`);
+    }
+    return { ok: true, code: 0 };
+  }
+}
+
+module.exports = { AutoResumeEngine };

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "claude-resume-hub",
+  "version": "1.0.0",
+  "description": "Run Claude Code and auto-continue the moment a usage/session limit resets — with a live dashboard and desktop alerts. Cross-platform, zero-dependency.",
+  "bin": {
+    "claude-resume-hub": "bin/cli.js",
+    "crh": "bin/cli.js"
+  },
+  "type": "commonjs",
+  "engines": {
+    "node": ">=16"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node bin/cli.js",
+    "test": "node --test"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "anthropic",
+    "cli",
+    "rate-limit",
+    "usage-limit",
+    "session-limit",
+    "auto-resume",
+    "automation",
+    "continue"
+  ],
+  "author": "Ibrahim Kalemci",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/IbrahimKalemci/claude-resume-hub.git"
+  },
+  "bugs": {
+    "url": "https://github.com/IbrahimKalemci/claude-resume-hub/issues"
+  },
+  "homepage": "https://github.com/IbrahimKalemci/claude-resume-hub#readme"
+}