claude-wake 0.1.0

package/lib/send/win32.js

@@ -0,0 +1,133 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { BASE_DIR, ensureBaseDir } from "../config.js";
+
+/**
+ * Windows sender: PowerShell Set-Clipboard + SendKeys, hardened:
+ *
+ * - Runtime values travel as base64(JSON) in argv — sidesteps BOTH string
+ *   interpolation and the stdin OEM-codepage mojibake that garbled non-ASCII
+ *   messages (hostile review).
+ * - Window matching: title must END WITH the editor name (VS Code convention),
+ *   not a loose substring ("Cursor" matched browser tabs).
+ * - AppActivate's return value is NOT trusted: Windows focus-stealing
+ *   prevention lets it "succeed" while the real foreground window is
+ *   unchanged. We verify via GetForegroundWindow → PID and abort otherwise.
+ * - Clipboard is set only AFTER the foreground verification.
+ *
+ * Status: community-verify (implemented to spec, no live QA environment).
+ */
+
+const SENDER_PS1 = path.join(BASE_DIR, "sender.ps1");
+
+const PS_SOURCE = `
+$ErrorActionPreference = "Stop"
+try {
+  $req = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($args[0])) | ConvertFrom-Json
+} catch { Write-Output "ERR: bad request: $_"; exit 1 }
+
+Add-Type @"
+using System;
+using System.Runtime.InteropServices;
+public class CWWin {
+  [DllImport("user32.dll")] public static extern IntPtr GetForegroundWindow();
+  [DllImport("user32.dll")] public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint pid);
+}
+"@
+
+function Get-ForegroundPid {
+  $h = [CWWin]::GetForegroundWindow()
+  $fgPid = 0
+  [void][CWWin]::GetWindowThreadProcessId($h, [ref]$fgPid)
+  return $fgPid
+}
+
+if ($req.uri -and $req.uri.Length -gt 0) {
+  try { Start-Process $req.uri } catch { Write-Output "ERR: open uri: $_"; exit 1 }
+  Start-Sleep -Milliseconds $req.delayMs
+}
+
+# Editor windows: title ends with the product name (strict suffix, not substring).
+$targets = Get-Process | Where-Object {
+  $_.MainWindowTitle -and $_.MainWindowTitle.EndsWith($req.title, [StringComparison]::OrdinalIgnoreCase)
+}
+if (-not $targets) { Write-Output "ERR: no window title ending with '$($req.title)'"; exit 2 }
+$targetPids = @($targets | ForEach-Object { $_.Id })
+
+# If the URI focus already put the editor in the foreground, don't fight it
+# with AppActivate; otherwise try AppActivate once.
+if ($targetPids -notcontains (Get-ForegroundPid)) {
+  $ws = New-Object -ComObject WScript.Shell
+  [void]$ws.AppActivate($targets[0].Id)
+  Start-Sleep -Milliseconds 500
+}
+
+# Trust only the actual foreground window (AppActivate lies under
+# focus-stealing prevention).
+if ($targetPids -notcontains (Get-ForegroundPid)) {
+  Write-Output "ERR: editor is not the foreground window"; exit 2
+}
+
+try { Set-Clipboard -Value $req.message } catch { Write-Output "ERR: clipboard: $_"; exit 1 }
+$ws2 = New-Object -ComObject WScript.Shell
+Start-Sleep -Milliseconds 300
+$ws2.SendKeys("^v")
+Start-Sleep -Milliseconds 250
+$ws2.SendKeys("{ENTER}")
+Write-Output "OK"
+`;
+
+function ensureSenderScript() {
+  ensureBaseDir();
+  if (
+    !fs.existsSync(SENDER_PS1) ||
+    fs.readFileSync(SENDER_PS1, "utf8") !== PS_SOURCE
+  ) {
+    fs.writeFileSync(SENDER_PS1, PS_SOURCE, { mode: 0o600 });
+  }
+}
+
+function runPs(inputObj, timeoutMs) {
+  ensureSenderScript();
+  const b64 = Buffer.from(JSON.stringify(inputObj), "utf8").toString("base64");
+  const r = spawnSync(
+    "powershell.exe",
+    [
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-File",
+      SENDER_PS1,
+      b64,
+    ],
+    { encoding: "utf8", timeout: timeoutMs },
+  );
+  if (r.error) return `ERR: powershell: ${r.error.message}`;
+  return (r.stdout || "").trim() || `ERR: exit ${r.status}`;
+}
+
+export function checkPermissions() {
+  const r = spawnSync(
+    "powershell.exe",
+    ["-NoProfile", "-Command", "$PSVersionTable.PSVersion.Major"],
+    { encoding: "utf8", timeout: 15000 },
+  );
+  if (r.status !== 0)
+    return { ok: false, detail: "powershell.exe not available" };
+  return { ok: true, detail: `powershell ${String(r.stdout).trim()}` };
+}
+
+export function send({ uri, editor, message, focusDelayMs }) {
+  const out = runPs(
+    {
+      message,
+      uri: uri || "",
+      title: editor.windowTitle,
+      delayMs: Math.round(focusDelayMs),
+    },
+    focusDelayMs + 30000,
+  );
+  return { ok: out.startsWith("OK"), detail: out };
+}

package/lib/state.js

@@ -0,0 +1,139 @@
+import fs from "node:fs";
+import path from "node:path";
+import { STATE_FILE, ensureBaseDir } from "./config.js";
+
+const MAX_FIRED = 500;
+const MAX_UUIDS = 1000;
+/**
+ * Two fire times for the same session closer than this are the same limit
+ * episode. Duplicate rate-limit lines for one episode carry timestamps and
+ * relative phrases that drift by up to a few minutes — exact-key dedupe alone
+ * would double-fire (found in hostile review).
+ */
+const PROXIMITY_MS = 15 * 60_000;
+
+export function emptyState() {
+  return { offsets: {}, pending: [], fired: [], uuids: [] };
+}
+
+/** Bookkeeping key: session + fire minute. Dedupe itself also uses proximity. */
+export function episodeKey(sessionId, fireEpochMs) {
+  return `${sessionId}@${Math.floor(fireEpochMs / 60000)}`;
+}
+
+function keyParts(key) {
+  const at = key.lastIndexOf("@");
+  if (at === -1) return null;
+  const minute = Number(key.slice(at + 1));
+  if (!Number.isFinite(minute)) return null;
+  return { sessionId: key.slice(0, at), fireEpochMs: minute * 60000 };
+}
+
+export function loadState(file = STATE_FILE) {
+  let st;
+  try {
+    st = JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    st = null;
+  }
+  if (typeof st !== "object" || st === null) st = emptyState();
+  if (typeof st.offsets !== "object" || st.offsets === null) st.offsets = {};
+  if (!Array.isArray(st.pending)) st.pending = [];
+  if (!Array.isArray(st.fired)) st.fired = [];
+  if (!Array.isArray(st.uuids)) st.uuids = [];
+
+  // Defensive on load: drop malformed entries, collapse per-episode duplicates.
+  const kept = [];
+  for (const p of st.pending) {
+    if (!p || typeof p.sessionId !== "string" || !Number.isFinite(p.fire))
+      continue;
+    p.key = p.key || episodeKey(p.sessionId, p.fire);
+    if (
+      isDuplicateEpisode({ ...st, pending: kept }, p.sessionId, p.fire, p.uuid)
+    )
+      continue;
+    kept.push(p);
+  }
+  st.pending = kept;
+  return st;
+}
+
+export function saveState(st, file = STATE_FILE) {
+  ensureBaseDir();
+  const tmp = file + ".tmp";
+  fs.writeFileSync(tmp, JSON.stringify(st), { mode: 0o600 });
+  fs.renameSync(tmp, file); // atomic on POSIX; near-atomic on Windows
+}
+
+/** True if this (session, fire time, uuid) matches an episode we already track. */
+function isDuplicateEpisode(st, sessionId, fireEpochMs, uuid) {
+  if (uuid && st.uuids.includes(uuid)) return true;
+  for (const p of st.pending) {
+    if (
+      p.sessionId === sessionId &&
+      Math.abs(p.fire - fireEpochMs) < PROXIMITY_MS
+    )
+      return true;
+  }
+  for (const key of st.fired) {
+    const parts = keyParts(key);
+    if (
+      parts &&
+      parts.sessionId === sessionId &&
+      Math.abs(parts.fireEpochMs - fireEpochMs) < PROXIMITY_MS
+    )
+      return true;
+  }
+  return false;
+}
+
+/** Queue an episode unless it duplicates a pending/fired one. Returns true if added. */
+export function addEpisode(
+  st,
+  { sessionId, fireEpochMs, transcriptPath, eventEpochMs, uuid },
+) {
+  if (isDuplicateEpisode(st, sessionId, fireEpochMs, uuid)) {
+    rememberUuid(st, uuid); // a duplicate line still consumes its uuid
+    return false;
+  }
+  st.pending.push({
+    key: episodeKey(sessionId, fireEpochMs),
+    sessionId,
+    fire: fireEpochMs,
+    transcriptPath,
+    event: eventEpochMs,
+    uuid: uuid || undefined,
+  });
+  rememberUuid(st, uuid);
+  return true;
+}
+
+function rememberUuid(st, uuid) {
+  if (!uuid || st.uuids.includes(uuid)) return;
+  st.uuids.push(uuid);
+  if (st.uuids.length > MAX_UUIDS) st.uuids = st.uuids.slice(-MAX_UUIDS);
+}
+
+export function markFired(st, key) {
+  st.pending = st.pending.filter((p) => p.key !== key);
+  st.fired.push(key);
+  if (st.fired.length > MAX_FIRED) st.fired = st.fired.slice(-MAX_FIRED);
+}
+
+export function duePending(st, nowMs) {
+  return st.pending
+    .filter((p) => p.fire <= nowMs)
+    .sort((a, b) => a.fire - b.fire);
+}
+
+/** Forget offsets for transcript files that no longer exist (keeps state small). */
+export function pruneOffsets(st, existingPaths) {
+  const keep = new Set(existingPaths);
+  for (const p of Object.keys(st.offsets)) {
+    if (!keep.has(p)) delete st.offsets[p];
+  }
+}
+
+export function stateDir() {
+  return path.dirname(STATE_FILE);
+}

package/lib/watch.js

@@ -0,0 +1,276 @@
+import fs from "node:fs";
+import {
+  LOCK_FILE,
+  LOG_FILE,
+  ensureBaseDir,
+  projectsDir,
+  isPaused,
+  loadConfig,
+} from "./config.js";
+import { getEditor } from "./editors.js";
+import { listTranscripts, scanFile, sessionResumedAfter } from "./detect.js";
+import { parseResetEpochMs } from "./parse-reset.js";
+import {
+  addEpisode,
+  duePending,
+  loadState,
+  markFired,
+  pruneOffsets,
+  saveState,
+} from "./state.js";
+import { sendResume } from "./send/index.js";
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/* ---------------- single-instance lock ----------------
+ * pid + heartbeat mtime: the watcher touches the lock every loop, so a lock
+ * whose mtime is stale is dead regardless of what its pid now points at
+ * (pid-reuse after crash/reboot permanently blocked the daemon — hostile
+ * review). */
+
+// A lock is stale if its heartbeat is older than this. Set at watch start to
+// comfortably exceed the poll interval AND a long firePass, so the owner never
+// starves its own lock (which would let a second daemon steal it → double fire).
+let lockStaleMs = 3 * 60_000;
+
+export function setLockStaleFromPoll(pollSeconds) {
+  lockStaleMs = Math.max(3 * 60_000, Math.round(pollSeconds * 1000 * 4));
+}
+
+function lockIsLive() {
+  try {
+    const stat = fs.statSync(LOCK_FILE);
+    if (Date.now() - stat.mtimeMs > lockStaleMs) return { live: false };
+    const pid = parseInt(fs.readFileSync(LOCK_FILE, "utf8"), 10);
+    return { live: true, pid };
+  } catch {
+    return { live: false };
+  }
+}
+
+export function acquireLock() {
+  ensureBaseDir();
+  const cur = lockIsLive();
+  if (cur.live && cur.pid !== process.pid) return { ok: false, pid: cur.pid };
+  fs.writeFileSync(LOCK_FILE, String(process.pid), { mode: 0o600 });
+  const release = () => {
+    try {
+      if (parseInt(fs.readFileSync(LOCK_FILE, "utf8"), 10) === process.pid) {
+        fs.rmSync(LOCK_FILE, { force: true });
+      }
+    } catch {
+      /* best effort */
+    }
+  };
+  for (const sig of ["SIGINT", "SIGTERM"]) {
+    process.on(sig, () => {
+      release();
+      process.exit(0);
+    });
+  }
+  process.on("exit", release);
+  return { ok: true };
+}
+
+export function touchLock() {
+  try {
+    const now = new Date();
+    fs.utimesSync(LOCK_FILE, now, now);
+  } catch {
+    /* re-created next write */
+  }
+}
+
+/* ---------------- core passes ---------------- */
+
+/**
+ * One scan pass: read appended transcript bytes, queue new limit episodes.
+ * Exported for tests. Mutates `st`.
+ */
+export function scanPass(st, cfg, log, nowMs = Date.now()) {
+  const files = listTranscripts(projectsDir(cfg));
+  if (files === null) return; // transient readdir failure: keep offsets intact
+  pruneOffsets(st, files);
+
+  for (const file of files) {
+    if (st.offsets[file] === undefined) {
+      // New file appearing while we run: a brand-new session transcript —
+      // scan it from the start (its history IS new). First-run priming of
+      // pre-existing files happens in primeOffsets().
+      st.offsets[file] = 0;
+    }
+    const { events, newOffset } = scanFile(file, st.offsets[file]);
+    st.offsets[file] = newOffset;
+
+    for (const ev of events) {
+      if (nowMs - ev.eventEpochMs > cfg.maxEventAgeHours * 3600_000) continue;
+
+      // Reference the EVENT time, not scan time — see parse-reset.js header.
+      let reset = parseResetEpochMs(ev.text, ev.eventEpochMs);
+      if (reset === null) {
+        reset = ev.eventEpochMs + cfg.fallbackWaitHours * 3600_000;
+        log(
+          `could not parse reset from ${JSON.stringify(ev.text.slice(0, 120))}; ` +
+            `falling back to event+${cfg.fallbackWaitHours}h`,
+        );
+      }
+      const fire = reset + cfg.marginSeconds * 1000;
+      if (
+        addEpisode(st, {
+          sessionId: ev.sessionId,
+          fireEpochMs: fire,
+          transcriptPath: ev.transcriptPath,
+          eventEpochMs: ev.eventEpochMs,
+          uuid: ev.uuid,
+        })
+      ) {
+        log(
+          `detected limit session=${ev.sessionId} :: ${JSON.stringify(ev.text.slice(0, 140))} ` +
+            `-> fire ${new Date(fire).toLocaleString()}`,
+        );
+      }
+    }
+  }
+}
+
+/** Fire everything due. Mutates `st`. */
+export async function firePass(
+  st,
+  cfg,
+  log,
+  { dryRun = false, nowMs = Date.now() } = {},
+) {
+  const due = duePending(st, nowMs);
+  const editor = getEditor(cfg.editor);
+  let attempts = 0;
+
+  for (const p of due) {
+    if (
+      cfg.skipIfResumed &&
+      p.transcriptPath &&
+      sessionResumedAfter(p.transcriptPath, p.event)
+    ) {
+      log(`skip session=${p.sessionId} (user already resumed after the limit)`);
+      markFired(st, p.key);
+      continue;
+    }
+    if (attempts > 0) await sleep(cfg.fireSpacingSeconds * 1000);
+    attempts++;
+    touchLock(); // heartbeat during a long fire burst so the lock never goes stale
+    log(`RESUME session=${p.sessionId}${dryRun ? " (dry-run)" : ""}`);
+    try {
+      const res = await sendResume({
+        sessionId: p.sessionId,
+        editor,
+        message: cfg.message,
+        focusDelayMs: cfg.focusDelayMs,
+        allowUnverifiedPaste: cfg.allowUnverifiedPaste,
+        dryRun,
+        log,
+      });
+      if (!res.ok) log(`send failed session=${p.sessionId}: ${res.detail}`);
+    } catch (err) {
+      log(`send error session=${p.sessionId}: ${err.message}`);
+    }
+    touchLock(); // a send can take tens of seconds — re-stamp so the lock
+    // heartbeat never goes stale mid-burst (would let a 2nd daemon steal it)
+    // Fired OR failed: retire the episode either way. A failed send (e.g.
+    // wrong window focused at 3am) must not retry-loop forever into someone's
+    // typing; the guarded message + next limit event give the next chance.
+    markFired(st, p.key);
+  }
+  return attempts;
+}
+
+/** Prime offsets to EOF on first run so history is never replayed. */
+export function primeOffsets(st, cfg, log) {
+  if (Object.keys(st.offsets).length > 0) return;
+  const files = listTranscripts(projectsDir(cfg)) || [];
+  for (const f of files) {
+    try {
+      st.offsets[f] = fs.statSync(f).size;
+    } catch {
+      /* ignore */
+    }
+  }
+  log(
+    `primed offsets for ${files.length} transcript files (watching for NEW limits only)`,
+  );
+}
+
+/** Keep the daemon's side-channel files from growing unbounded. */
+function truncateSideLogs() {
+  for (const suffix of [".stdout", ".stderr"]) {
+    try {
+      const f = LOG_FILE + suffix;
+      if (fs.statSync(f).size > 5 * 1024 * 1024) fs.truncateSync(f, 0);
+    } catch {
+      /* absent */
+    }
+  }
+}
+
+/* ---------------- main loop ---------------- */
+
+export async function watchLoop(cfg, log, { dryRun = false } = {}) {
+  setLockStaleFromPoll(cfg.pollSeconds);
+  const lock = acquireLock();
+  if (!lock.ok) {
+    // Exit 0: "already running" is success. A non-zero exit here made
+    // launchd/systemd (KeepAlive / Restart=on-failure) respawn-flap every
+    // 10s for as long as a manual watch held the lock (hostile review).
+    log(
+      `another claude-wake watcher is already running (pid ${lock.pid}) — exiting`,
+    );
+    process.exitCode = 0;
+    return;
+  }
+  // Startup I/O wrapped: a persistent failure here (disk full, perms) must not
+  // reject → non-zero exit → daemon restart flap. Log and exit 0 instead.
+  let st;
+  try {
+    truncateSideLogs();
+    log(
+      `claude-wake watching ${projectsDir(cfg)} ` +
+        `(editor=${cfg.editor}, margin=${cfg.marginSeconds}s${dryRun ? ", DRY-RUN" : ""})`,
+    );
+    st = loadState();
+    primeOffsets(st, cfg, log);
+    saveState(st);
+  } catch (err) {
+    log(`startup failed (not restarting): ${err.message}`);
+    process.exitCode = 0;
+    return;
+  }
+
+  let wasPaused = false;
+  for (;;) {
+    try {
+      // Live-reload config each cycle so message/margin/editor edits (e.g. from
+      // the desktop app) apply without a restart. Cheap: one small file read.
+      cfg = loadConfig({ warn: () => {} });
+      setLockStaleFromPoll(cfg.pollSeconds);
+      touchLock(); // heartbeat even while paused, so the lock stays owned
+      if (isPaused()) {
+        if (!wasPaused) log("paused — auto-resume suspended");
+        wasPaused = true;
+      } else {
+        if (wasPaused) {
+          // Resume: ignore anything that happened while paused (you paused on
+          // purpose) by re-priming offsets to EOF and dropping stale pending.
+          st.offsets = {};
+          st.pending = [];
+          primeOffsets(st, cfg, log);
+          log("resumed — watching for new limits");
+        }
+        wasPaused = false;
+        scanPass(st, cfg, log);
+        await firePass(st, cfg, log, { dryRun });
+      }
+      saveState(st);
+    } catch (err) {
+      log(`loop error: ${err.stack || err.message}`);
+    }
+    await sleep(cfg.pollSeconds * 1000);
+  }
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "claude-wake",
+  "version": "0.1.0",
+  "description": "Auto-resume Claude Code (VS Code extension panels) when your usage limit resets — while you sleep.",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "usage-limit",
+    "rate-limit",
+    "auto-resume",
+    "auto-retry",
+    "vscode",
+    "anthropic"
+  ],
+  "license": "MIT",
+  "author": "Kazuki Nakayashiki",
+  "type": "module",
+  "bin": {
+    "claude-wake": "bin/claude-wake.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "docs/design.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kazuki-sf/claude-wake.git"
+  }
+}