@lazyagent/lazy-agents 0.0.1

package/src/wrapper.integration.test.js

@@ -0,0 +1,138 @@
+'use strict';
+
+/**
+ * Integration test for wrapper.js restart logic.
+ * Uses CLAUDE_BIN to inject a fake "claude" script that exits immediately
+ * with a non-zero code, verifying that the wrapper restarts it.
+ *
+ * Note: node-pty spawns a real PTY so the fake script runs inside a
+ * pseudo-terminal — behaviour is identical to the real Claude binary.
+ *
+ * CLAUDE_BIN is split on spaces: "node /path/to/fake.js" →
+ *   bin='node', extraArgs=['/path/to/fake.js']
+ * pty.spawn('node', ['/path/to/fake.js', 'test-prompt'], ...)
+ */
+
+const { execFile } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const WRAPPER = path.join(__dirname, 'wrapper.js');
+
+// Write a tiny fake-claude script to a temp file
+function makeFakeClaude(exitCode, delayMs = 100) {
+  const script = `
+    const delay = ${delayMs};
+    const code = ${exitCode};
+    setTimeout(() => process.exit(code), delay);
+  `;
+  const file = path.join(os.tmpdir(), `fake-claude-${Date.now()}.js`);
+  fs.writeFileSync(file, script);
+  return file;
+}
+
+// Fake claude that prints a rate-limit message then exits after a short delay
+// (simulates the wrapper detecting the message and sending Enter to the pty)
+function makeRateLimitClaude() {
+  const script = `
+    process.stdout.write('usage limit reached\\n');
+    process.stdout.write('What do you want to do?\\n');
+    process.stdout.write('1. Wait for rate limit to reset\\n');
+    process.stdout.write('2. Exit\\n');
+    // Exit cleanly after 2s
+    setTimeout(() => process.exit(0), 2000);
+  `;
+  const file = path.join(os.tmpdir(), `fake-ratelimit-${Date.now()}.js`);
+  fs.writeFileSync(file, script);
+  return file;
+}
+
+// Build CLAUDE_BIN using 'node' (on PATH) to avoid spaces in process.execPath
+function claudeBin(scriptFile) {
+  return `node "${scriptFile}"`;
+}
+
+test('wrapper restarts once after non-zero exit', (done) => {
+  const fakeClaude = makeFakeClaude(1, 100);
+  let startCount = 0;
+
+  const wrapper = execFile(
+    process.execPath,
+    [WRAPPER, 'test-prompt'],
+    {
+      env: { ...process.env, CLAUDE_BIN: claudeBin(fakeClaude) },
+      timeout: 10000,
+    },
+    () => {
+      fs.unlinkSync(fakeClaude);
+      expect(startCount).toBeGreaterThanOrEqual(2);
+      done();
+    }
+  );
+
+  wrapper.stderr.on('data', (data) => {
+    const text = data.toString();
+    if (text.includes('Starting ')) {
+      startCount++;
+      if (startCount >= 2) wrapper.kill();
+    }
+  });
+}, 10000);
+
+test('wrapper does NOT restart after clean exit (code 0)', (done) => {
+  const fakeClaude = makeFakeClaude(0, 100);
+  let startCount = 0;
+
+  const wrapper = execFile(
+    process.execPath,
+    [WRAPPER, 'test-prompt'],
+    {
+      env: { ...process.env, CLAUDE_BIN: claudeBin(fakeClaude) },
+      timeout: 5000,
+    },
+    () => {
+      fs.unlinkSync(fakeClaude);
+      expect(startCount).toBe(1);
+      done();
+    }
+  );
+
+  wrapper.stderr.on('data', (data) => {
+    if (data.toString().includes('Starting ')) startCount++;
+  });
+}, 8000);
+
+test('wrapper exits with error when no args given', (done) => {
+  execFile(process.execPath, [WRAPPER], (err) => {
+    expect(err).not.toBeNull();
+    expect(err.code).not.toBe(0);
+    done();
+  });
+}, 5000);
+
+test('wrapper auto-selects option 1 when rate-limit menu is detected', (done) => {
+  const fakeClaude = makeRateLimitClaude();
+  let detectedAutoSelect = false;
+
+  const wrapper = execFile(
+    process.execPath,
+    [WRAPPER, 'test-prompt'],
+    {
+      env: { ...process.env, CLAUDE_BIN: claudeBin(fakeClaude) },
+      timeout: 12000,
+    },
+    (err) => {
+      try { fs.unlinkSync(fakeClaude); } catch (_) {}
+      expect(detectedAutoSelect).toBe(true);
+      done();
+    }
+  );
+
+  const check = (data) => {
+    const text = data.toString();
+    if (text.includes('Could not parse reset time') || text.includes('auto-resuming')) detectedAutoSelect = true;
+  };
+  wrapper.stderr.on('data', check);
+  wrapper.stdout.on('data', check);
+}, 15000);

package/src/wrapper.js

@@ -0,0 +1,266 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Rate-limit-aware Claude Code wrapper.
+ *
+ * Usage: node wrapper.js "<claude prompt>"
+ *
+ * Design:
+ *   node-pty spawns the command inside a real pseudo-terminal via PowerShell so:
+ *     • Claude Code gets a real PTY — its TUI renders normally.
+ *     • We can read stdout to detect the rate-limit menu.
+ *     • We can write to stdin to auto-select "wait for reset".
+ *     • PowerShell handles quoted multi-word args correctly (cmd.exe mangles them).
+ *
+ *   Rate-limit detection & auto-resume:
+ *     When Claude prints rate-limit text we auto-select option 1 (wait) after
+ *     800 ms. We then parse the reset time (e.g. "8:00 PM", "30 minutes") and
+ *     schedule an auto-resume 60s after the reset time. Fully hands-free.
+ *
+ *   Restart logic:
+ *     exit code 0  → clean exit, stop.
+ *     any other code → restart after RESTART_DELAY_MS.
+ *     The agent re-registers automatically with its saved agentToken so
+ *     conversation context and paused tasks are fully preserved.
+ *
+ *   Testing:
+ *     Override the command via CLAUDE_BIN env var, e.g.:
+ *       CLAUDE_BIN="node 'C:\\fake.js'" node wrapper.js "prompt"
+ *     The value is used as-is as the command prefix in PowerShell.
+ */
+
+const fs = require('fs');
+const pty = require('node-pty');
+
+const RESTART_DELAY_MS = 5 * 1000;
+const RATE_LIMIT_RE = /you.{0,10}ve hit your limit|rate limit reached|usage limit reached/i;
+const RESUME_BUFFER_MS = 60 * 1000; // wait 60s past the reset time before resuming
+const POWERSHELL = 'C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe';
+
+/**
+ * Parse a reset time from Claude's rate-limit output.
+ * Matches patterns like "2:30 PM", "14:30", "8:00 pm", "resets at 8 PM", "3pm (Asia/Jerusalem)"
+ * Returns a Date for today (or tomorrow if the time already passed).
+ */
+function parseResetTime(text) {
+  // Strip all ANSI/VT escape sequences (colors, cursor movement, erase, etc.)
+  const clean = text
+    .replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '')   // CSI sequences: ESC [ ... letter
+    .replace(/\x1b[()][AB012]/g, '')           // character set designations
+    .replace(/\x1b[DABC]/g, '')               // cursor up/down/forward/back (no bracket)
+    .replace(/\x1b[78]/g, '')                 // save/restore cursor
+    .replace(/\r/g, '\n');                    // carriage returns → newlines so words don't overwrite
+
+  // Narrow search to text near "reset" — if not found, no time to parse
+  const resetMatch = clean.match(/reset[s]?[^.\n]{0,80}/i);
+  if (!resetMatch) return null;
+  const searchText = resetMatch[0];
+
+  // Try "H:MM AM/PM" or "HH:MM AM/PM"
+  let m = searchText.match(/(\d{1,2}):(\d{2})\s*(am|pm)/i);
+  if (m) {
+    let h = parseInt(m[1], 10);
+    const min = parseInt(m[2], 10);
+    const ampm = m[3].toLowerCase();
+    if (ampm === 'pm' && h !== 12) h += 12;
+    if (ampm === 'am' && h === 12) h = 0;
+    return buildTargetDate(h, min, clean);
+  }
+  // Try "H AM/PM" without minutes (e.g. "3pm", "8 PM")
+  m = searchText.match(/(\d{1,2})\s*(am|pm)/i);
+  if (m) {
+    let h = parseInt(m[1], 10);
+    const ampm = m[2].toLowerCase();
+    if (ampm === 'pm' && h !== 12) h += 12;
+    if (ampm === 'am' && h === 12) h = 0;
+    return buildTargetDate(h, 0, clean);
+  }
+  // Try 24-hour "HH:MM"
+  m = searchText.match(/(\d{1,2}):(\d{2})/);
+  if (m) {
+    const h = parseInt(m[1], 10);
+    const min = parseInt(m[2], 10);
+    if (h >= 0 && h <= 23 && min >= 0 && min <= 59) {
+      return buildTargetDate(h, min, clean);
+    }
+  }
+  // Try "X minutes" or "X mins"
+  m = searchText.match(/(\d+)\s*min/i);
+  if (m) {
+    return new Date(Date.now() + parseInt(m[1], 10) * 60 * 1000);
+  }
+  return null;
+}
+
+function buildTargetDate(hours, minutes, fullText) {
+  // Extract timezone if present, e.g. "(Asia/Jerusalem)"
+  const tzMatch = fullText && fullText.match(/\(([A-Za-z_]+\/[A-Za-z_]+)\)/);
+  const tz = tzMatch ? tzMatch[1] : Intl.DateTimeFormat().resolvedOptions().timeZone;
+
+  // Get current date components in the target timezone
+  const now = new Date();
+  const parts = new Intl.DateTimeFormat('en-CA', {
+    timeZone: tz,
+    year: 'numeric', month: '2-digit', day: '2-digit',
+  }).formatToParts(now);
+  const p = Object.fromEntries(parts.map(({ type, value }) => [type, value]));
+
+  // Build an ISO string that looks like local time in `tz`, then find its UTC equivalent
+  // by asking Intl what UTC instant maps back to that local time.
+  const localStr = `${p.year}-${p.month}-${p.day}T${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:00`;
+
+  // Binary-search the UTC instant whose wall-clock in `tz` equals localStr
+  const targetLocal = new Date(localStr); // treat as UTC epoch anchor (value doesn't matter, just ms)
+  // Compute offset: difference between UTC and tz wall-clock at `now`
+  const formatter = new Intl.DateTimeFormat('en-CA', {
+    timeZone: tz,
+    year: 'numeric', month: '2-digit', day: '2-digit',
+    hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: false,
+  });
+  // Format `now` in tz, parse it back as if it were UTC to get the offset
+  const tzParts = formatter.formatToParts(now);
+  const q = Object.fromEntries(tzParts.map(({ type, value }) => [type, value]));
+  const tzWall = new Date(`${q.year}-${q.month}-${q.day}T${q.hour === '24' ? '00' : q.hour}:${q.minute}:${q.second}Z`);
+  const offsetMs = now.getTime() - tzWall.getTime();
+
+  let target = new Date(new Date(localStr + 'Z').getTime() + offsetMs);
+
+  if (target <= now) target = new Date(target.getTime() + 24 * 60 * 60 * 1000);
+  return target;
+}
+
+const rawArgs = process.argv.slice(2);
+if (rawArgs.length === 0) {
+  console.error('[lazy] Usage: node wrapper.js "<claude prompt>"');
+  process.exit(1);
+}
+
+// If the single arg is a path to a .txt file, read the prompt from it
+// (used by launch.js to avoid PowerShell splitting on spaces/commas)
+let args;
+if (rawArgs.length === 1 && rawArgs[0].endsWith('.txt') && fs.existsSync(rawArgs[0])) {
+  const prompt = fs.readFileSync(rawArgs[0], 'utf8').trim();
+  try { fs.unlinkSync(rawArgs[0]); } catch (_) {}
+  args = [prompt];
+} else {
+  args = rawArgs;
+}
+
+// Allow overriding the claude binary for testing.
+// Value is used as-is as the command prefix inside PowerShell's & operator.
+// Example: CLAUDE_BIN="node 'C:\\fake.js'"
+const CLAUDE_BIN = process.env.CLAUDE_BIN || 'claude';
+
+let term = null;
+let stopping = false;
+
+// Forward user keystrokes to the pty (set up once; survives restarts via shared `term` ref)
+if (process.stdin.isTTY) process.stdin.setRawMode(true);
+process.stdin.resume();
+process.stdin.on('data', (d) => {
+  if (term) term.write(d.toString());
+});
+
+// Resize pty whenever outer terminal resizes (set up once)
+process.stdout.on('resize', () => {
+  if (term) term.resize(process.stdout.columns || 220, process.stdout.rows || 50);
+});
+
+function run() {
+  const cols = process.stdout.columns || 220;
+  const rows = process.stdout.rows || 50;
+
+  // Build PowerShell command — single-quote args to preserve spaces/commas
+  const quotedArgs = args.map(a => `'${a.replace(/'/g, "''")}'`).join(' ');
+  const cmdStr = `& ${CLAUDE_BIN} ${quotedArgs}`;
+
+  console.error(`[lazy] Starting ${CLAUDE_BIN}...`);
+
+  term = pty.spawn(POWERSHELL, ['-NoProfile', '-Command', cmdStr], {
+    name: 'xterm-256color',
+    cols,
+    rows,
+    cwd: process.cwd(),
+    env: process.env,
+  });
+
+  let rateLimitDetected = false;
+  let menuShown = false;
+  let resumeTimer = null;
+  let savedResetTime = null;
+  let recentOutput = '';
+
+  term.onData((data) => {
+    process.stdout.write(data); // forward to outer terminal — TUI renders normally
+
+    // Always buffer output while we're in rate-limit detection mode
+    if (rateLimitDetected) recentOutput += data;
+
+    // Step 1: detect rate limit message
+    if (!rateLimitDetected && RATE_LIMIT_RE.test(data)) {
+      rateLimitDetected = true;
+      recentOutput += data;
+    }
+
+    // Step 1b: scan every chunk for reset time until we find one
+    if (rateLimitDetected && !menuShown && !savedResetTime) {
+      const candidate = parseResetTime(data);
+      if (candidate && candidate.getTime() - Date.now() > 5 * 60 * 1000) {
+        savedResetTime = candidate;
+      }
+    }
+
+    // Step 2: once rate limit seen, wait for the actual menu before sending "1"
+    if (rateLimitDetected && !menuShown && /Stop and wait|rate.limit.option|What do you want to do/i.test(data)) {
+      menuShown = true;
+      setTimeout(() => { if (term) term.write('\r'); }, 200);
+
+      const resetTime = savedResetTime;
+      if (resetTime) {
+        const delayMs = resetTime.getTime() - Date.now() + RESUME_BUFFER_MS;
+        const resumeAt = new Date(resetTime.getTime() + RESUME_BUFFER_MS);
+        setTimeout(() => {
+          process.stderr.write(`\n[lazy] Resets at ${resetTime.toLocaleTimeString()}, auto-resuming at ${resumeAt.toLocaleTimeString()} (${Math.ceil(delayMs / 60000)} min), will send "continue" after reset\n`);
+        }, 500);
+        resumeTimer = setTimeout(() => {
+          if (term) {
+            process.stderr.write(`\n[lazy] Resuming...\n`);
+            term.write('\r');
+            setTimeout(() => { if (term) term.write('continue\r'); }, 1000);
+            rateLimitDetected = false;
+            menuShown = false;
+            savedResetTime = null;
+            recentOutput = '';
+          }
+        }, Math.max(delayMs, 0));
+      } else {
+        process.stderr.write('\n[lazy] Could not parse reset time — waiting for Claude to resume.\n');
+        rateLimitDetected = false;
+        menuShown = false;
+        recentOutput = '';
+      }
+    }
+  });
+
+  term.onExit(({ exitCode }) => {
+    if (resumeTimer) { clearTimeout(resumeTimer); resumeTimer = null; }
+    term = null;
+    if (stopping) return;
+    if (exitCode === 0) {
+      console.error('[lazy] claude exited cleanly.');
+      return;
+    }
+    console.error(`\n[lazy] claude exited (code ${exitCode}) — restarting in ${RESTART_DELAY_MS / 1000}s...`);
+    console.error('[lazy] Context is preserved — agent will re-register with saved token.');
+    setTimeout(run, RESTART_DELAY_MS);
+  });
+}
+
+process.on('SIGINT', () => {
+  stopping = true;
+  if (term) term.kill();
+  process.exit(0);
+});
+
+run();

package/src/wrapper.test.js

@@ -0,0 +1,128 @@
+'use strict';
+
+/**
+ * Wrapper is a thin restart-on-exit script — the testable unit is the
+ * argument validation and the restart logic. We test these via the exported
+ * constants and by smoke-testing the module loads without errors.
+ */
+
+describe('wrapper constants', () => {
+  let src;
+  beforeAll(() => {
+    src = require('fs').readFileSync(require('path').join(__dirname, 'wrapper.js'), 'utf8');
+  });
+
+  test('RESTART_DELAY_MS is a positive number', () => {
+    const m = src.match(/RESTART_DELAY_MS\s*=\s*(\d+)/);
+    expect(m).not.toBeNull();
+    const val = parseInt(m[1], 10);
+    expect(val).toBeGreaterThan(0);
+  });
+
+  test('uses node-pty for PTY spawning', () => {
+    expect(src).toMatch(/require\(['"]node-pty['"]\)/);
+  });
+
+  test('uses PowerShell instead of cmd.exe', () => {
+    expect(src).toMatch(/POWERSHELL/);
+    expect(src).toMatch(/powershell\.exe/);
+    expect(src).not.toMatch(/CMD_EXE/);
+  });
+
+  test('forwards output to process.stdout', () => {
+    expect(src).toMatch(/process\.stdout\.write/);
+  });
+
+  test('auto-selects option 1 on rate-limit detection', () => {
+    expect(src).toMatch(/RATE_LIMIT_RE/);
+    expect(src).toMatch(/term\.write\(['"]\\r['"]\)/);
+  });
+
+  test('schedules auto-resume after parsing reset time', () => {
+    expect(src).toMatch(/parseResetTime/);
+    expect(src).toMatch(/RESUME_BUFFER_MS/);
+    expect(src).toMatch(/auto-resume/i);
+  });
+
+  test('resets rateLimitHandled so subsequent limits are caught', () => {
+    expect(src).toMatch(/rateLimitDetected\s*=\s*false/);
+  });
+
+  test('CLAUDE_BIN env var is supported for binary override', () => {
+    expect(src).toMatch(/CLAUDE_BIN/);
+  });
+});
+
+describe('parseResetTime', () => {
+  // Extract parseResetTime and buildTargetDate from wrapper source
+  let parseResetTime;
+  beforeAll(() => {
+    const src = require('fs').readFileSync(require('path').join(__dirname, 'wrapper.js'), 'utf8');
+    // Extract the two functions from source and eval them
+    const buildTargetMatch = src.match(/function buildTargetDate[\s\S]*?^}/m);
+    const parseMatch = src.match(/function parseResetTime[\s\S]*?^}/m);
+    // eslint-disable-next-line no-eval
+    eval(buildTargetMatch[0]);
+    // eslint-disable-next-line no-eval
+    parseResetTime = eval(`(${parseMatch[0]})`);
+    // Inject buildTargetDate into parseResetTime's scope
+    const combined = `(function() { ${buildTargetMatch[0]}; return ${parseMatch[0].replace('function parseResetTime', 'function parseResetTime')}; })()`;
+    // eslint-disable-next-line no-eval
+    parseResetTime = eval(combined);
+  });
+
+  test('parses "8:00 PM" format', () => {
+    const result = parseResetTime('Rate limit resets at 8:00 PM');
+    expect(result).toBeInstanceOf(Date);
+    expect(result.getHours()).toBe(20);
+    expect(result.getMinutes()).toBe(0);
+  });
+
+  test('parses "2:30 pm" format', () => {
+    const result = parseResetTime('resets at 2:30 pm');
+    expect(result).toBeInstanceOf(Date);
+    expect(result.getHours()).toBe(14);
+    expect(result.getMinutes()).toBe(30);
+  });
+
+  test('parses "8 PM" without minutes', () => {
+    const result = parseResetTime('limit resets at 8 PM');
+    expect(result).toBeInstanceOf(Date);
+    expect(result.getHours()).toBe(20);
+  });
+
+  test('parses "12:00 AM" as midnight', () => {
+    const result = parseResetTime('resets at 12:00 AM');
+    expect(result).toBeInstanceOf(Date);
+    expect(result.getHours()).toBe(0);
+  });
+
+  test('parses "12:30 PM" as 12:30', () => {
+    const result = parseResetTime('resets at 12:30 PM');
+    expect(result).toBeInstanceOf(Date);
+    expect(result.getHours()).toBe(12);
+    expect(result.getMinutes()).toBe(30);
+  });
+
+  test('parses "30 minutes" relative format', () => {
+    const before = Date.now();
+    const result = parseResetTime('rate limit resets in 30 minutes');
+    expect(result).toBeInstanceOf(Date);
+    const diffMin = (result.getTime() - before) / 60000;
+    expect(diffMin).toBeGreaterThan(29);
+    expect(diffMin).toBeLessThan(31);
+  });
+
+  test('parses "5 min" shorthand', () => {
+    const before = Date.now();
+    const result = parseResetTime('resets in 5 min');
+    const diffMin = (result.getTime() - before) / 60000;
+    expect(diffMin).toBeGreaterThan(4);
+    expect(diffMin).toBeLessThan(6);
+  });
+
+  test('returns null for unparseable text', () => {
+    const result = parseResetTime('some random text with no time');
+    expect(result).toBeNull();
+  });
+});