claude-wake 0.1.0

package/lib/doctor.js

@@ -0,0 +1,135 @@
+import fs from "node:fs";
+import { spawnSync } from "node:child_process";
+import { loadConfig, projectsDir } from "./config.js";
+import { getEditor } from "./editors.js";
+import { listTranscripts } from "./detect.js";
+import { checkSendPermissions } from "./send/index.js";
+import { daemonStatus, readManifest } from "./install.js";
+
+const OK = "  ✔";
+const BAD = "  ✘";
+const WARN = "  ⚠";
+
+export async function runDoctor() {
+  const cfg = loadConfig({ warn: (m) => console.log(`${WARN} ${m}`) });
+  const editor = getEditor(cfg.editor);
+  let failures = 0;
+
+  console.log("claude-wake doctor\n");
+
+  // Node
+  const major = parseInt(process.versions.node.split(".")[0], 10);
+  if (major >= 18) console.log(`${OK} node ${process.versions.node}`);
+  else {
+    console.log(`${BAD} node ${process.versions.node} — need >= 18`);
+    failures++;
+  }
+
+  // Transcript root
+  const root = projectsDir(cfg);
+  const transcripts = listTranscripts(root);
+  if (transcripts !== null) {
+    console.log(
+      `${OK} transcripts: ${root} (${transcripts.length} session files)`,
+    );
+    if (transcripts.length === 0)
+      console.log(
+        `${WARN}   no session files yet — open a Claude Code panel once to create one`,
+      );
+  } else {
+    console.log(`${BAD} transcript dir not readable: ${root}`);
+    console.log(
+      "      is Claude Code installed and used at least once on this machine?",
+    );
+    failures++;
+  }
+
+  // Editor / URI target
+  console.log(`${OK} editor preset: ${editor.name} (${editor.scheme}://)`);
+  if (process.platform === "darwin") {
+    const r = spawnSync("/usr/bin/open", ["-Ra", editor.appName], {
+      stdio: "ignore",
+    });
+    if (r.status === 0) console.log(`${OK} ${editor.appName} is installed`);
+    else {
+      console.log(
+        `${BAD} ${editor.appName} not found (config "editor" wrong?)`,
+      );
+      failures++;
+    }
+  }
+
+  // Send layer / permissions
+  try {
+    const perm = await checkSendPermissions(editor);
+    if (perm.ok) console.log(`${OK} send layer ready (${perm.detail})`);
+    else {
+      console.log(`${BAD} send layer: ${perm.detail}`);
+      failures++;
+      if (process.platform === "darwin") {
+        const { openPermissionUi, APP_DIR } = await import("./send/darwin.js");
+        console.log("\n  macOS Accessibility permission needed (one-time):");
+        console.log(
+          "    1. System Settings → Privacy & Security → Accessibility",
+        );
+        console.log(`    2. Add and enable: ${APP_DIR}`);
+        console.log(
+          "    (note: changing the `editor` config rebuilds KeySender.app — re-grant after that)",
+        );
+        console.log("    (opening both for you now …)");
+        openPermissionUi();
+      } else if (process.platform === "linux") {
+        console.log("    install hints: apt/dnf install xdotool xclip   (X11)");
+        console.log(
+          "                   apt/dnf install wl-clipboard wtype   (Wayland, experimental + needs allowUnverifiedPaste)",
+        );
+      }
+    }
+  } catch (err) {
+    console.log(`${BAD} send layer error: ${err.message}`);
+    failures++;
+  }
+
+  // Daemon + recorded launch paths still valid?
+  const d = daemonStatus();
+  if (d.installed) {
+    console.log(
+      `${d.running ? OK : WARN} daemon installed, ${d.running ? "running" : "NOT running"}`,
+    );
+    const manifest = readManifest();
+    if (manifest) {
+      for (const key of ["node", "cliBin"]) {
+        const p = manifest[key];
+        if (p && !fs.existsSync(p)) {
+          console.log(`${BAD} daemon launch path is gone: ${p}`);
+          console.log(
+            "      (Node was upgraded/moved?) fix: claude-wake install   (re-registers with current paths)",
+          );
+          failures++;
+        }
+      }
+    }
+  } else {
+    console.log(
+      `${WARN} daemon not installed (optional) — \`claude-wake install\` for always-on`,
+    );
+  }
+
+  if (process.platform === "linux") {
+    if (!process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) {
+      console.log(
+        `${WARN} no DISPLAY/WAYLAND_DISPLAY in this shell — sends need a GUI session`,
+      );
+    }
+    console.log(
+      `${WARN} systemd note: if the daemon can't reach your display, run: systemctl --user import-environment DISPLAY WAYLAND_DISPLAY XAUTHORITY`,
+    );
+  }
+
+  console.log(
+    failures === 0
+      ? "\nAll checks passed. Try it end-to-end: claude-wake test"
+      : `\n${failures} check(s) failed — fix the ✘ items above, then re-run: claude-wake doctor`,
+  );
+  return failures === 0;
+}

package/lib/editors.js

@@ -0,0 +1,87 @@
+/**
+ * Editor presets. `scheme` is the URI protocol the editor registers;
+ * the extension id part of the URI is always anthropic.claude-code.
+ *
+ * - appName: macOS application name (for `activate`)
+ * - bundleIds: macOS bundle identifiers accepted as the frontmost app before
+ *   any keystroke (names like "Electron" are ambiguous across apps — bundle
+ *   ids are not)
+ * - windowTitle: suffix matched against the active window title (Linux X11 /
+ *   Windows); VS Code-family titles end with the product name by default
+ */
+const PRESETS = {
+  vscode: {
+    scheme: "vscode",
+    appName: "Visual Studio Code",
+    bundleIds: ["com.microsoft.VSCode"],
+    windowTitle: "Visual Studio Code",
+  },
+  "vscode-insiders": {
+    scheme: "vscode-insiders",
+    appName: "Visual Studio Code - Insiders",
+    bundleIds: ["com.microsoft.VSCodeInsiders"],
+    windowTitle: "Visual Studio Code - Insiders",
+  },
+  cursor: {
+    scheme: "cursor",
+    appName: "Cursor",
+    bundleIds: ["com.todesktop.230313mzl4w4u92"],
+    windowTitle: "Cursor",
+  },
+  windsurf: {
+    scheme: "windsurf",
+    appName: "Windsurf",
+    bundleIds: ["com.exafunction.windsurf"],
+    windowTitle: "Windsurf",
+  },
+};
+
+const SESSION_ID_RE =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+
+export function isValidSessionId(id) {
+  return typeof id === "string" && SESSION_ID_RE.test(id);
+}
+
+// Schemes that must never be used as the "open" protocol — file:// can become
+// a UNC/SMB path on Windows (NTLM-hash leak), and the script/data family are
+// code-execution surfaces. Editor URL schemes are none of these.
+const BLOCKED_SCHEMES = new Set([
+  "file",
+  "javascript",
+  "vbscript",
+  "data",
+  "about",
+  "blob",
+  "http",
+  "https",
+  "smb",
+  "\\\\",
+]);
+
+export function getEditor(name) {
+  const preset = PRESETS[name];
+  if (preset) return { name, ...preset };
+  // Unknown name: treat it as a raw URI scheme (power users / new forks), but
+  // only if it looks like an editor scheme and is not a dangerous protocol.
+  // Frontmost verification then falls back to the vscode identity — if the
+  // fork's bundle id differs, sends fail closed rather than typing blind.
+  if (
+    typeof name === "string" &&
+    /^[a-z][a-z0-9+.-]{0,31}$/.test(name) &&
+    !BLOCKED_SCHEMES.has(name)
+  ) {
+    return { name, ...PRESETS.vscode, scheme: name };
+  }
+  return { name: "vscode", ...PRESETS.vscode };
+}
+
+/** Build the panel-focus URI. Throws on invalid session id — never interpolate unvalidated input. */
+export function buildFocusUri(editor, sessionId) {
+  if (!isValidSessionId(sessionId)) {
+    throw new Error(`invalid session id: ${String(sessionId).slice(0, 64)}`);
+  }
+  return `${editor.scheme}://anthropic.claude-code/open?session=${encodeURIComponent(sessionId)}`;
+}
+
+export const EDITOR_NAMES = Object.keys(PRESETS);

package/lib/install.js

@@ -0,0 +1,315 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { BASE_DIR, HOME, LOG_FILE, ensureBaseDir } from "./config.js";
+
+/**
+ * Autostart registration — a thin per-OS wrapper around `claude-wake watch`.
+ * The core never depends on the daemon; `watch` in a terminal is always enough.
+ *
+ * Path-stability (hostile review): `process.execPath` resolves symlinks to a
+ * VERSION-PINNED binary (Homebrew Cellar, nvm versions dir) that dies on the
+ * next `brew upgrade node` / `nvm install` — leaving launchd retrying a
+ * nonexistent path forever. We prefer the `node` living next to the invoked
+ * CLI bin (npm installs them side by side behind stable symlinks), record
+ * both paths in an install manifest for `doctor` to re-check, and warn
+ * loudly when the chosen paths look version-pinned.
+ */
+
+const LABEL = "com.claude-wake.watch";
+const MANIFEST = path.join(BASE_DIR, "install.json");
+
+const VERSIONED_PATH_RE = /\/Cellar\/node|[\\/]\.nvm[\\/]versions[\\/]|node@\d/;
+
+/** Prefer the stable `node` symlink sitting next to the CLI bin. */
+function stableNodePath(cliBin) {
+  const sibling = path.join(
+    path.dirname(cliBin),
+    process.platform === "win32" ? "node.exe" : "node",
+  );
+  try {
+    if (fs.existsSync(sibling)) return sibling;
+  } catch {
+    /* fall through */
+  }
+  return process.execPath;
+}
+
+/**
+ * The CLI entry to launch. `process.argv[1]` is the path the user actually
+ * invoked (the npm global bin shim), which is stable across upgrades —
+ * unlike import.meta.url, which is the realpath.
+ */
+export function resolveLaunchPaths(argv1) {
+  const cliBin = path.resolve(argv1);
+  const node = stableNodePath(cliBin);
+  const warnings = [];
+  for (const p of [node, cliBin]) {
+    if (VERSIONED_PATH_RE.test(p)) {
+      warnings.push(
+        `${p} looks version-pinned — after upgrading Node (nvm/brew), re-run \`claude-wake install\``,
+      );
+    }
+  }
+  return { node, cliBin, warnings };
+}
+
+function writeManifest(info) {
+  ensureBaseDir();
+  fs.writeFileSync(MANIFEST, JSON.stringify(info, null, 2), { mode: 0o600 });
+}
+
+export function readManifest() {
+  try {
+    return JSON.parse(fs.readFileSync(MANIFEST, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function xmlEscape(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+/* ---------------- macOS: launchd LaunchAgent ---------------- */
+
+function launchAgentPath() {
+  return path.join(HOME, "Library", "LaunchAgents", `${LABEL}.plist`);
+}
+
+function installDarwin(node, cliBin) {
+  // KeepAlive on SuccessfulExit=false: restart crashes, but let a clean exit
+  // stop the job. KeepAlive=true + "duplicate lock → exit" respawn-flapped
+  // every 10s for as long as a manual watch ran (hostile review).
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${xmlEscape(node)}</string>
+    <string>${xmlEscape(cliBin)}</string>
+    <string>watch</string>
+    <string>--quiet</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key><false/>
+  </dict>
+  <key>ProcessType</key><string>Background</string>
+  <key>StandardOutPath</key><string>${xmlEscape(LOG_FILE)}.stdout</string>
+  <key>StandardErrorPath</key><string>${xmlEscape(LOG_FILE)}.stderr</string>
+</dict>
+</plist>
+`;
+  const dest = launchAgentPath();
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.writeFileSync(dest, plist);
+  const uid = process.getuid();
+  spawnSync("launchctl", ["bootout", `gui/${uid}/${LABEL}`], {
+    stdio: "ignore",
+  });
+  const r = spawnSync("launchctl", ["bootstrap", `gui/${uid}`, dest], {
+    encoding: "utf8",
+  });
+  if (r.status !== 0)
+    throw new Error(`launchctl bootstrap failed: ${r.stderr || r.stdout}`);
+  return dest;
+}
+
+function uninstallDarwin() {
+  const uid = process.getuid();
+  spawnSync("launchctl", ["bootout", `gui/${uid}/${LABEL}`], {
+    stdio: "ignore",
+  });
+  fs.rmSync(launchAgentPath(), { force: true });
+}
+
+function statusDarwin() {
+  const uid = process.getuid();
+  const r = spawnSync("launchctl", ["print", `gui/${uid}/${LABEL}`], {
+    encoding: "utf8",
+  });
+  if (r.status !== 0)
+    return { installed: fs.existsSync(launchAgentPath()), running: false };
+  return { installed: true, running: /state = running/.test(r.stdout) };
+}
+
+/* ---------------- Linux: systemd --user ---------------- */
+
+function systemdUnitPath() {
+  const cfgHome = process.env.XDG_CONFIG_HOME || path.join(HOME, ".config");
+  return path.join(cfgHome, "systemd", "user", "claude-wake.service");
+}
+
+function installLinux(node, cliBin) {
+  // Restart=on-failure + duplicate-lock exiting 0 = no respawn flap.
+  // Paths are quoted (systemd syntax) in case $HOME contains spaces.
+  const unit = `[Unit]
+Description=claude-wake: auto-resume Claude Code panels after usage-limit resets
+After=graphical-session.target
+PartOf=graphical-session.target
+
+[Service]
+ExecStart="${node}" "${cliBin}" watch --quiet
+Restart=on-failure
+RestartSec=10
+
+[Install]
+WantedBy=graphical-session.target
+`;
+  const dest = systemdUnitPath();
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.writeFileSync(dest, unit);
+  let r = spawnSync("systemctl", ["--user", "daemon-reload"], {
+    encoding: "utf8",
+  });
+  if (r.status !== 0)
+    throw new Error(`systemctl daemon-reload failed: ${r.stderr}`);
+  r = spawnSync(
+    "systemctl",
+    ["--user", "enable", "--now", "claude-wake.service"],
+    {
+      encoding: "utf8",
+    },
+  );
+  if (r.status !== 0) throw new Error(`systemctl enable failed: ${r.stderr}`);
+  return dest;
+}
+
+function uninstallLinux() {
+  spawnSync(
+    "systemctl",
+    ["--user", "disable", "--now", "claude-wake.service"],
+    {
+      stdio: "ignore",
+    },
+  );
+  fs.rmSync(systemdUnitPath(), { force: true });
+  spawnSync("systemctl", ["--user", "daemon-reload"], { stdio: "ignore" });
+}
+
+function statusLinux() {
+  const r = spawnSync(
+    "systemctl",
+    ["--user", "is-active", "claude-wake.service"],
+    {
+      encoding: "utf8",
+    },
+  );
+  return {
+    installed: fs.existsSync(systemdUnitPath()),
+    running: (r.stdout || "").trim() === "active",
+  };
+}
+
+/* ---------------- Windows: Startup-folder VBS (hidden) ---------------- */
+
+function startupVbsPath() {
+  return path.join(
+    process.env.APPDATA || path.join(HOME, "AppData", "Roaming"),
+    "Microsoft",
+    "Windows",
+    "Start Menu",
+    "Programs",
+    "Startup",
+    "claude-wake.vbs",
+  );
+}
+
+function installWin32(node, cliBin) {
+  // VBS string literals escape quotes by doubling them.
+  const q = (s) => `""${s.replace(/"/g, '""')}""`;
+  const cmd = `${q(node)} ${q(cliBin)} watch --quiet`;
+  const vbs = `' claude-wake autostart (hidden window)\r\nCreateObject("WScript.Shell").Run "${cmd}", 0, False\r\n`;
+  const dest = startupVbsPath();
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.writeFileSync(dest, vbs);
+  spawnSync("wscript.exe", [dest], { stdio: "ignore" }); // start now, hidden
+  return dest;
+}
+
+function uninstallWin32() {
+  fs.rmSync(startupVbsPath(), { force: true });
+  // Best effort: stop a running watcher via its lock pid.
+  try {
+    const pid = parseInt(
+      fs.readFileSync(path.join(BASE_DIR, "watch.lock"), "utf8"),
+      10,
+    );
+    if (Number.isFinite(pid)) process.kill(pid);
+  } catch {
+    /* not running */
+  }
+}
+
+function statusWin32() {
+  let running = false;
+  try {
+    const lock = path.join(BASE_DIR, "watch.lock");
+    const pid = parseInt(fs.readFileSync(lock, "utf8"), 10);
+    const fresh = Date.now() - fs.statSync(lock).mtimeMs < 3 * 60_000;
+    if (Number.isFinite(pid) && fresh) {
+      process.kill(pid, 0);
+      running = true;
+    }
+  } catch {
+    /* not running */
+  }
+  return { installed: fs.existsSync(startupVbsPath()), running };
+}
+
+/* ---------------- dispatch ---------------- */
+
+export function installDaemon(argv1) {
+  ensureBaseDir();
+  const { node, cliBin, warnings } = resolveLaunchPaths(argv1);
+  let dest;
+  switch (process.platform) {
+    case "darwin":
+      dest = installDarwin(node, cliBin);
+      break;
+    case "linux":
+      dest = installLinux(node, cliBin);
+      break;
+    case "win32":
+      dest = installWin32(node, cliBin);
+      break;
+    default:
+      throw new Error(`unsupported platform: ${process.platform}`);
+  }
+  writeManifest({ node, cliBin, dest, installedAt: new Date().toISOString() });
+  return { dest, warnings };
+}
+
+export function uninstallDaemon() {
+  switch (process.platform) {
+    case "darwin":
+      uninstallDarwin();
+      break;
+    case "linux":
+      uninstallLinux();
+      break;
+    case "win32":
+      uninstallWin32();
+      break;
+    default:
+      throw new Error(`unsupported platform: ${process.platform}`);
+  }
+  fs.rmSync(MANIFEST, { force: true });
+}
+
+export function daemonStatus() {
+  switch (process.platform) {
+    case "darwin":
+      return statusDarwin();
+    case "linux":
+      return statusLinux();
+    case "win32":
+      return statusWin32();
+    default:
+      return { installed: false, running: false };
+  }
+}

package/lib/log.js

@@ -0,0 +1,43 @@
+import fs from "node:fs";
+import { LOG_FILE, ensureBaseDir } from "./config.js";
+
+const MAX_LOG_BYTES = 5 * 1024 * 1024; // rotate at 5 MB, keep the last 1 MB
+const KEEP_BYTES = 1024 * 1024;
+
+function stamp() {
+  const d = new Date();
+  const p = (n, w = 2) => String(n).padStart(w, "0");
+  return (
+    `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ` +
+    `${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`
+  );
+}
+
+function rotateIfNeeded() {
+  try {
+    const { size } = fs.statSync(LOG_FILE);
+    if (size <= MAX_LOG_BYTES) return;
+    const fd = fs.openSync(LOG_FILE, "r");
+    const buf = Buffer.alloc(KEEP_BYTES);
+    fs.readSync(fd, buf, 0, KEEP_BYTES, size - KEEP_BYTES);
+    fs.closeSync(fd);
+    fs.writeFileSync(LOG_FILE, buf);
+  } catch {
+    /* rotation is best-effort */
+  }
+}
+
+/** Logger that mirrors to stdout (foreground) and appends to the log file. */
+export function createLogger({ quiet = false } = {}) {
+  ensureBaseDir();
+  return function log(msg) {
+    const line = `[${stamp()}] ${msg}`;
+    if (!quiet) console.log(line);
+    try {
+      rotateIfNeeded();
+      fs.appendFileSync(LOG_FILE, line + "\n");
+    } catch {
+      /* logging must never crash the watcher */
+    }
+  };
+}