claude-wake 0.1.0

package/lib/parse-reset.js

@@ -0,0 +1,192 @@
+/**
+ * Parse Claude Code limit messages into an absolute epoch (ms).
+ *
+ * Observed renders (verified against real transcripts):
+ *   "You've hit your session limit · resets 1:20am (America/Los_Angeles)"
+ *   "5-hour limit reached - resets 3pm (UTC)"
+ *   "You've hit your weekly limit · resets Oct 9, 10am"
+ *   "Claude usage limit reached. Resets at 2pm"
+ *   "Please try again in 5 hours"
+ *
+ * Pure module. Timezone math uses only Intl (DST-safe iterative offset
+ * correction — same technique as date-fns-tz). No dependencies.
+ *
+ * `nowMs` should be the EVENT timestamp (when the message was rendered), not
+ * scan time: relative phrases ("in 5 hours") are relative to the render, and
+ * scan-time reference points made duplicate lines parse to drifting epochs
+ * (double-fire bug found in hostile review).
+ */
+
+const MONTHS = {
+  jan: 1,
+  feb: 2,
+  mar: 3,
+  apr: 4,
+  may: 5,
+  jun: 6,
+  jul: 7,
+  aug: 8,
+  sep: 9,
+  oct: 10,
+  nov: 11,
+  dec: 12,
+};
+
+const ABSOLUTE_RE =
+  /reset(?:s)?\s+(?:at\s+)?(?:([A-Za-z]{3,9})\.?\s+(\d{1,2})(?:st|nd|rd|th)?,?\s+)?(\d{1,2})(?::(\d{2}))?\s*([ap]\.?m\.?)?(?:\s*\(([^)]+)\))?/i;
+
+const RELATIVE_RE = /try again in\s+(\d+)\s*(hour|minute|min)\w*/i;
+
+/**
+ * Monthly limits can reset up to ~a month out; anything further is a
+ * year-boundary mis-parse ("Dec 31" seen in January). 32 days covers monthly
+ * while still catching the wrap.
+ */
+const MAX_FUTURE_MS = 32 * 24 * 3600_000;
+
+/** Cap on relative "try again in N hours" so a garbage/forged N can't park a
+ *  pending entry with an un-representable (Invalid Date) fire time. */
+const MAX_RELATIVE_HOURS = 24 * 14;
+
+/** Wall-clock parts of `utcMs` as seen in `timeZone`. */
+function wallClockInZone(utcMs, timeZone) {
+  const dtf = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false,
+  });
+  const parts = {};
+  for (const p of dtf.formatToParts(new Date(utcMs))) parts[p.type] = p.value;
+  return {
+    year: +parts.year,
+    month: +parts.month,
+    day: +parts.day,
+    hour: parts.hour === "24" ? 0 : +parts.hour,
+    minute: +parts.minute,
+    second: +parts.second,
+  };
+}
+
+function offsetMs(timeZone, utcMs) {
+  const w = wallClockInZone(utcMs, timeZone);
+  const asUtc = Date.UTC(
+    w.year,
+    w.month - 1,
+    w.day,
+    w.hour,
+    w.minute,
+    w.second,
+  );
+  return asUtc - Math.floor(utcMs / 1000) * 1000;
+}
+
+/** Epoch ms for wall time (y,mo,d,hh,mm) in `timeZone`. DST-safe. */
+export function zonedEpochMs(year, month, day, hour, minute, timeZone) {
+  const wallAsUtc = Date.UTC(year, month - 1, day, hour, minute, 0);
+  let guess = wallAsUtc;
+  for (let i = 0; i < 3; i++) {
+    const next = wallAsUtc - offsetMs(timeZone, guess);
+    if (next === guess) break;
+    guess = next;
+  }
+  return guess;
+}
+
+function isValidTimeZone(tz) {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: tz });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Parse `text` → epoch ms of the reset, or null.
+ * May return a PAST epoch (reset already elapsed) — callers fire immediately,
+ * which is the correct behavior for "the reset already happened".
+ */
+export function parseResetEpochMs(text, nowMs = Date.now()) {
+  if (typeof text !== "string" || !text) return null;
+
+  // Absolute forms first: when a message somehow contains both, the printed
+  // wall-clock reset is the precise one.
+  const m = ABSOLUTE_RE.exec(text);
+  if (m) {
+    const abs = parseAbsolute(m, nowMs);
+    if (abs !== null) return abs;
+  }
+
+  const rel = RELATIVE_RE.exec(text);
+  if (rel) {
+    const isHour = rel[2].toLowerCase().startsWith("hour");
+    const maxN = isHour ? MAX_RELATIVE_HOURS : MAX_RELATIVE_HOURS * 60;
+    const n = Math.min(+rel[1], maxN);
+    return nowMs + n * (isHour ? 3600_000 : 60_000);
+  }
+
+  return null;
+}
+
+function parseAbsolute(m, nowMs) {
+  const [, monName, dayStr, hhStr, mmStr, ampmRaw, tzRaw] = m;
+
+  let hour = +hhStr;
+  const minute = mmStr ? +mmStr : 0;
+  const ampm = ampmRaw ? ampmRaw.toLowerCase().replace(/\./g, "") : null;
+  if (ampm === "pm" && hour !== 12) hour += 12;
+  if (ampm === "am" && hour === 12) hour = 0;
+  if (hour > 23 || minute > 59) return null;
+  // Bare small number without am/pm ("resets 3") is too ambiguous — require
+  // either am/pm, a minutes part, or a 24h-looking hour.
+  if (!ampm && !mmStr && hour < 10) return null;
+
+  const tz =
+    tzRaw && isValidTimeZone(tzRaw.trim())
+      ? tzRaw.trim()
+      : Intl.DateTimeFormat().resolvedOptions().timeZone;
+
+  const today = wallClockInZone(nowMs, tz);
+
+  if (monName) {
+    const month = MONTHS[monName.slice(0, 3).toLowerCase()];
+    if (!month || +dayStr < 1 || +dayStr > 31) return null;
+    let epoch = zonedEpochMs(today.year, month, +dayStr, hour, minute, tz);
+    // Year-boundary correction (hostile review): "resets Dec 31" scanned in
+    // January must mean LAST year's Dec 31 (already passed → fire now), not
+    // 12 months out. Bound: real resets are at most ~7 days away.
+    if (epoch > nowMs + MAX_FUTURE_MS) {
+      epoch = zonedEpochMs(today.year - 1, month, +dayStr, hour, minute, tz);
+    }
+    return epoch;
+  }
+
+  let epoch = zonedEpochMs(
+    today.year,
+    today.month,
+    today.day,
+    hour,
+    minute,
+    tz,
+  );
+  if (epoch <= nowMs) {
+    // Same wall time tomorrow. Tomorrow's DATE comes from calendar arithmetic
+    // on today's wall parts — deriving it from nowMs+24h skipped a day on
+    // 23-hour DST days (hostile review).
+    const t = new Date(Date.UTC(today.year, today.month - 1, today.day + 1));
+    epoch = zonedEpochMs(
+      t.getUTCFullYear(),
+      t.getUTCMonth() + 1,
+      t.getUTCDate(),
+      hour,
+      minute,
+      tz,
+    );
+  }
+  return epoch;
+}

package/lib/send/darwin.js

@@ -0,0 +1,233 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync, spawnSync } from "node:child_process";
+import { BASE_DIR, ensureBaseDir } from "../config.js";
+
+/**
+ * macOS sender — the reference implementation (live-verified).
+ *
+ * Why a compiled .app: webview inputs ignore synthetic keystrokes but accept a
+ * paste (Cmd+V). Sending keys needs the Accessibility permission, and macOS
+ * grants TCC permissions to the *responsible app bundle*. A stable compiled
+ * KeySender.app is granted once and then works from any context (foreground
+ * watch, launchd daemon). osacompile ships with macOS — no dependency.
+ *
+ * Hardening (from hostile review):
+ * - The editor's identity (app name + accepted BUNDLE IDS) is compiled into
+ *   the app, not passed per-request — a frontmost check on bundle ids can't
+ *   be fooled by other Electron apps (whose process name is also "Electron"),
+ *   and same-user processes can't retarget the app via the request file.
+ * - The applet deletes the request file immediately after reading it, so a
+ *   stray double-click of KeySender.app replays nothing.
+ * - The clipboard is set INSIDE the applet, AFTER the frontmost verification
+ *   (no clobbering the user's clipboard on an aborted send), via AppleScript
+ *   `set the clipboard to` — never through a shell string.
+ * - Delay crosses the boundary as integer milliseconds: AppleScript's
+ *   string→number coercion is locale-dependent ("2.5" throws on comma-decimal
+ *   locales, as a modal dialog at 3am).
+ *
+ * Request file (0600), one value per line:
+ *   1: mode "send" | "check"   2: focus URI ("" to skip)
+ *   3: delay in ms (integer)   4: the message (single line, enforced upstream)
+ */
+
+export const APP_DIR = path.join(BASE_DIR, "KeySender.app");
+const REQUEST_FILE = path.join(BASE_DIR, "send-request.txt");
+const STATUS_FILE = path.join(BASE_DIR, "sender-status.txt");
+const SRC_FILE = path.join(BASE_DIR, "keysender.applescript");
+
+function appleScriptSource(editor) {
+  const bundleIdsCSV = editor.bundleIds.join(",");
+  // appName/bundleIds come from code presets only (editors.js) — still,
+  // refuse to compile anything that could break out of the AppleScript
+  // string literal or the CSV contract.
+  for (const v of [editor.appName, bundleIdsCSV]) {
+    if (!/^[A-Za-z0-9 ._-]+(,[A-Za-z0-9 ._-]+)*$/.test(v)) {
+      throw new Error(`unsafe editor identity: ${v}`);
+    }
+  }
+  return String.raw`
+property expectedApp : "${editor.appName}"
+property expectedBundleIds : "${bundleIdsCSV}"
+
+on writeStatus(msg)
+	set statusFile to (POSIX path of (path to home folder)) & ".claude-wake/sender-status.txt"
+	try
+		do shell script "printf %s " & quoted form of msg & " > " & quoted form of statusFile
+	end try
+end writeStatus
+
+on splitCSV(csv)
+	set oldDelims to AppleScript's text item delimiters
+	set AppleScript's text item delimiters to ","
+	set parts to text items of csv
+	set AppleScript's text item delimiters to oldDelims
+	return parts
+end splitCSV
+
+try
+	set base to (POSIX path of (path to home folder)) & ".claude-wake/"
+	set reqFile to base & "send-request.txt"
+
+	try
+		set reqData to do shell script "cat " & quoted form of reqFile
+	on error
+		return -- no request (e.g. double-clicked in Finder): do nothing
+	end try
+	-- consume the request so it can never replay
+	try
+		do shell script "rm -f " & quoted form of reqFile
+	end try
+
+	set req to paragraphs of reqData
+	if (count of req) < 4 then
+		my writeStatus("ERR: malformed request")
+		return
+	end if
+	set modeLine to item 1 of req
+	set uriLine to item 2 of req
+	set delayMs to (item 3 of req) as integer
+	set messageLine to item 4 of req
+
+	if modeLine is "check" then
+		-- Permission probe: a bare modifier press is invisible to apps but
+		-- still requires Accessibility (errors with 1002 if not granted).
+		try
+			tell application "System Events"
+				key down control
+				key up control
+			end tell
+			my writeStatus("OK")
+		on error errMsg
+			my writeStatus("ERR: " & errMsg)
+		end try
+		return
+	end if
+
+	if uriLine is not "" then
+		try
+			do shell script "open " & quoted form of uriLine
+		on error errMsg
+			my writeStatus("ERR: open failed: " & errMsg)
+			return
+		end try
+		delay (delayMs / 1000)
+	end if
+
+	try
+		tell application expectedApp to activate
+	end try
+	delay 0.6
+
+	-- Never type into an unknown window: verify the frontmost app's BUNDLE ID.
+	set frontOk to false
+	try
+		tell application "System Events"
+			set frontBundle to bundle identifier of first application process whose frontmost is true
+		end tell
+		repeat with candidate in my splitCSV(expectedBundleIds)
+			if frontBundle is (candidate as text) then set frontOk to true
+		end repeat
+	on error
+		set frontOk to false
+	end try
+	if not frontOk then
+		my writeStatus("ERR: frontmost app is not the expected editor")
+		return
+	end if
+
+	-- Clipboard only now, after verification (no clobber on aborted sends).
+	set the clipboard to messageLine
+	delay 0.1
+
+	try
+		tell application "System Events"
+			keystroke "v" using command down
+			delay 0.25
+			key code 36 -- Return
+		end tell
+		my writeStatus("OK")
+	on error errMsg
+		my writeStatus("ERR: " & errMsg)
+	end try
+on error topErr
+	my writeStatus("ERR: " & topErr)
+end try
+`;
+}
+
+/**
+ * Compile KeySender.app if missing or its source changed (editor identity is
+ * baked in, so switching config `editor` recompiles — and needs a one-time
+ * re-grant of Accessibility, which doctor explains).
+ * Returns true when (re)compiled.
+ */
+export function ensureKeySenderApp(editor) {
+  ensureBaseDir();
+  const source = appleScriptSource(editor);
+  const current = fs.existsSync(SRC_FILE)
+    ? fs.readFileSync(SRC_FILE, "utf8")
+    : null;
+  if (current === source && fs.existsSync(APP_DIR)) return false;
+  fs.writeFileSync(SRC_FILE, source, { mode: 0o600 });
+  fs.rmSync(APP_DIR, { recursive: true, force: true });
+  execFileSync("/usr/bin/osacompile", ["-o", APP_DIR, SRC_FILE], {
+    stdio: "pipe",
+  });
+  return true;
+}
+
+function runKeySender(requestLines, timeoutMs) {
+  fs.rmSync(STATUS_FILE, { force: true });
+  fs.writeFileSync(REQUEST_FILE, requestLines.join("\n") + "\n", {
+    mode: 0o600,
+  });
+  // `open -n -W` waits for the applet to exit, bounded by our own timeout.
+  const r = spawnSync("/usr/bin/open", ["-n", "-W", APP_DIR], {
+    timeout: timeoutMs,
+  });
+  if (r.error) throw new Error(`open KeySender.app failed: ${r.error.message}`);
+  try {
+    return fs.readFileSync(STATUS_FILE, "utf8").trim();
+  } catch {
+    return "ERR: no status written (app blocked, crashed, or timed out?)";
+  }
+}
+
+/** Strip newlines defensively — a newline in the request breaks the line contract. */
+function oneLine(s) {
+  return String(s).replace(/[\r\n]+/g, " ");
+}
+
+/** Accessibility/permission probe. Returns { ok, detail }. */
+export function checkPermissions(editor) {
+  ensureKeySenderApp(editor);
+  const status = runKeySender(["check", "", "0", ""], 15000);
+  return { ok: status === "OK", detail: status };
+}
+
+/**
+ * Full send: focus panel via URI, verify frontmost bundle id, clipboard ←
+ * message, paste + Enter. Returns { ok, detail }.
+ */
+export function send({ uri, editor, message, focusDelayMs }) {
+  ensureKeySenderApp(editor);
+  const status = runKeySender(
+    [
+      "send",
+      oneLine(uri || ""),
+      String(Math.round(focusDelayMs)),
+      oneLine(message),
+    ],
+    Math.ceil(focusDelayMs + 30000),
+  );
+  return { ok: status === "OK", detail: status };
+}
+
+/** Reveal the Accessibility pane + the app in Finder (used by doctor). */
+export function openPermissionUi() {
+  spawnSync("/usr/bin/open", [
+    "x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility",
+  ]);
+  spawnSync("/usr/bin/open", ["-R", APP_DIR]);
+}

package/lib/send/index.js

@@ -0,0 +1,47 @@
+import { buildFocusUri, getEditor } from "../editors.js";
+
+/**
+ * Platform dispatch for the send layer.
+ * Backends expose: checkPermissions(editor?) and
+ * send({uri, editor, message, focusDelayMs, allowUnverifiedPaste}).
+ */
+async function backend() {
+  switch (process.platform) {
+    case "darwin":
+      return import("./darwin.js");
+    case "linux":
+      return import("./linux.js");
+    case "win32":
+      return import("./win32.js");
+    default:
+      throw new Error(`unsupported platform: ${process.platform}`);
+  }
+}
+
+export async function checkSendPermissions(editor = getEditor("vscode")) {
+  return (await backend()).checkPermissions(editor);
+}
+
+/**
+ * Focus the session's panel and paste+submit the message.
+ * dryRun: log-only — the full pipeline minus any real side effect.
+ */
+export async function sendResume({
+  sessionId,
+  editor,
+  message,
+  focusDelayMs,
+  allowUnverifiedPaste = false,
+  dryRun,
+  log,
+}) {
+  const uri = buildFocusUri(editor, sessionId);
+  if (dryRun) {
+    log(
+      `DRY-RUN: would open ${uri}, wait ${focusDelayMs}ms, verify frontmost, paste + Enter`,
+    );
+    return { ok: true, detail: "dry-run" };
+  }
+  const b = await backend();
+  return b.send({ uri, editor, message, focusDelayMs, allowUnverifiedPaste });
+}

package/lib/send/linux.js

@@ -0,0 +1,149 @@
+import { spawnSync } from "node:child_process";
+
+/**
+ * Linux sender. X11 = solid path (xdotool verifies the active window before
+ * typing). Wayland = experimental AND blind (no portable active-window
+ * check), so it requires the explicit `allowUnverifiedPaste: true` config.
+ *
+ * Gotchas encoded here (from hostile review):
+ * - xclip/xsel/wl-copy daemonize to serve the selection and INHERIT stdio
+ *   pipes; spawnSync waits for pipe EOF, not child exit → with default stdio
+ *   the watcher hangs until something else takes the clipboard. Always spawn
+ *   them with stdout/stderr ignored.
+ * - Window title check is a strict SUFFIX match (VS Code titles end with the
+ *   product name); a bare substring match on "Cursor" hit browser tabs etc.
+ * - Clipboard is set only AFTER the active-window verification.
+ *
+ * Message text only ever travels via stdin (never a shell string).
+ * Status: community-verify (implemented to spec, no live QA environment).
+ */
+
+function has(cmd) {
+  return (
+    spawnSync(
+      "/bin/sh",
+      ["-c", 'command -v -- "$1" >/dev/null 2>&1', "sh", cmd],
+      {
+        stdio: "ignore",
+      },
+    ).status === 0
+  );
+}
+
+export function isWayland() {
+  return (
+    process.env.XDG_SESSION_TYPE === "wayland" || !!process.env.WAYLAND_DISPLAY
+  );
+}
+
+export function tooling() {
+  const wayland = isWayland();
+  const clipboard = wayland
+    ? has("wl-copy") && "wl-copy"
+    : (has("xclip") && "xclip") || (has("xsel") && "xsel");
+  const keys = wayland ? has("wtype") && "wtype" : has("xdotool") && "xdotool";
+  const opener = has("xdg-open") && "xdg-open";
+  return { wayland, clipboard, keys, opener };
+}
+
+function setClipboard(tool, text) {
+  const argv =
+    tool === "wl-copy"
+      ? ["wl-copy"]
+      : tool === "xclip"
+        ? ["xclip", "-selection", "clipboard"]
+        : ["xsel", "--clipboard", "--input"];
+  // stdout/stderr MUST be ignored: these tools fork a daemon that would
+  // otherwise hold the pipes open and block spawnSync indefinitely.
+  const r = spawnSync(argv[0], argv.slice(1), {
+    input: text,
+    stdio: ["pipe", "ignore", "ignore"],
+  });
+  if (r.status !== 0) throw new Error(`${tool} failed`);
+}
+
+function activeWindowMatchesSuffix(title) {
+  // X11 only. Fail closed: if we can't tell, we don't type.
+  const r = spawnSync("xdotool", ["getactivewindow", "getwindowname"], {
+    encoding: "utf8",
+  });
+  if (r.status !== 0) return false;
+  return (r.stdout || "").trim().toLowerCase().endsWith(title.toLowerCase());
+}
+
+const sleepMs = (ms) => spawnSync("sleep", [String(Math.max(0, ms) / 1000)]);
+
+export function checkPermissions() {
+  const t = tooling();
+  if (!t.opener) return { ok: false, detail: "xdg-open not found" };
+  if (!t.clipboard)
+    return {
+      ok: false,
+      detail: t.wayland
+        ? "wl-clipboard not installed (wl-copy)"
+        : "xclip or xsel not installed",
+    };
+  if (!t.keys)
+    return {
+      ok: false,
+      detail: t.wayland
+        ? "wtype not installed (Wayland is experimental; GNOME may block it entirely)"
+        : "xdotool not installed",
+    };
+  if (t.wayland)
+    return {
+      ok: true,
+      detail:
+        "wayland (experimental; sends are BLIND — requires allowUnverifiedPaste:true in config)",
+    };
+  return { ok: true, detail: "x11" };
+}
+
+export function send({
+  uri,
+  editor,
+  message,
+  focusDelayMs,
+  allowUnverifiedPaste,
+}) {
+  const t = tooling();
+  const perm = checkPermissions();
+  if (!perm.ok) return perm;
+
+  if (t.wayland && !allowUnverifiedPaste) {
+    return {
+      ok: false,
+      detail:
+        "wayland send is blind (no active-window verification available); " +
+        'set {"allowUnverifiedPaste": true} in ~/.claude-wake/config.json to accept that risk',
+    };
+  }
+
+  if (uri) {
+    const r = spawnSync("xdg-open", [uri], { stdio: "ignore" });
+    if (r.status !== 0) return { ok: false, detail: "xdg-open failed" };
+    sleepMs(focusDelayMs);
+  }
+
+  if (!t.wayland) {
+    if (!activeWindowMatchesSuffix(editor.windowTitle)) {
+      return { ok: false, detail: "active window is not the expected editor" };
+    }
+    setClipboard(t.clipboard, message); // after verification only
+    let r = spawnSync("xdotool", ["key", "--clearmodifiers", "ctrl+v"]);
+    if (r.status !== 0) return { ok: false, detail: "xdotool paste failed" };
+    sleepMs(250);
+    r = spawnSync("xdotool", ["key", "--clearmodifiers", "Return"]);
+    if (r.status !== 0) return { ok: false, detail: "xdotool Return failed" };
+    return { ok: true, detail: "sent (x11)" };
+  }
+
+  // Wayland (experimental, explicitly opted in): blind send after URI focus.
+  setClipboard(t.clipboard, message);
+  let r = spawnSync("wtype", ["-M", "ctrl", "v", "-m", "ctrl"]);
+  if (r.status !== 0) return { ok: false, detail: "wtype paste failed" };
+  sleepMs(250);
+  r = spawnSync("wtype", ["-P", "Return", "-p", "Return"]);
+  if (r.status !== 0) return { ok: false, detail: "wtype Return failed" };
+  return { ok: true, detail: "sent (wayland, unverified)" };
+}