lazy-apply 0.0.0-stage → 0.1.1

package/README.md

@@ -1,3 +1,28 @@
-# Temporary Holding Version
+# lazy-apply
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The runner for [Lazy Apply](https://lazyapply.online). It fills the job applications you approve in
+Lazy Apply, in a Chrome window on your own computer, and waits for you to press Submit.
+
+```
+npx lazy-apply
+```
+
+That one command:
+
+1. opens your browser so you can connect this computer to your Lazy Apply account (no token to copy);
+2. checks Google Chrome is installed;
+3. offers to start automatically in the background whenever you log in, keeping itself up to date.
+
+Needs Node.js 18 or newer and Google Chrome. Works on macOS, Windows and Linux.
+
+| Command | What it does |
+| --- | --- |
+| `npx lazy-apply` | Set up (once) and start |
+| `npx lazy-apply status` | Account, automatic start, whether it is running |
+| `npx lazy-apply autostart on` / `off` | Start, or stop starting, automatically at login |
+| `npx lazy-apply start` | Run now, in this terminal |
+| `npx lazy-apply logout` | Disconnect this computer |
+
+Settings are in `~/.lazy-apply/config.json` and the log in `~/.lazy-apply/runner.log`. Forms are
+filled in a separate Chrome profile (`~/.auto-apply/chrome-profile`), never your everyday one. Nothing is
+ever submitted without your Submit in Lazy Apply.

package/dist/cli.js

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+
+// packages/cli/src/cli.ts
+import { execFileSync, spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, hostname, platform, tmpdir, userInfo } from "node:os";
+import { dirname, join } from "node:path";
+import { createInterface } from "node:readline/promises";
+var VERSION = true ? "0.1.1" : "dev";
+var DEFAULT_APP = "https://lazyapply.online";
+var HOME = join(homedir(), ".lazy-apply");
+var CONFIG = join(HOME, "config.json");
+var LOG = join(HOME, "runner.log");
+var LABEL = "online.lazyapply.runner";
+var tty = process.stdout.isTTY;
+var paint = (code) => (s) => tty ? `\x1B[${code}m${s}\x1B[0m` : s;
+var bold = paint("1");
+var dim = paint("2");
+var teal = paint("36");
+var green = paint("32");
+var red = paint("31");
+var yellow = paint("33");
+var say = (s = "") => console.log(s);
+var fail = (s) => {
+  console.error(`${red("\u2717")} ${s}`);
+  process.exit(1);
+};
+function load() {
+  const fromFlag = flag("--app-url");
+  try {
+    const c = JSON.parse(readFileSync(CONFIG, "utf8"));
+    return fromFlag && fromFlag !== c.appUrl ? { appUrl: fromFlag } : c;
+  } catch {
+    return { appUrl: fromFlag || process.env.LAZY_APPLY_URL || DEFAULT_APP };
+  }
+}
+function save(c) {
+  mkdirSync(HOME, { recursive: true });
+  writeFileSync(CONFIG, JSON.stringify(c, null, 2), { mode: 384 });
+}
+function flag(name) {
+  const i = process.argv.indexOf(name);
+  return i > 0 ? process.argv[i + 1] : void 0;
+}
+function openBrowser(url) {
+  if (process.env.LAZY_APPLY_NO_BROWSER) return;
+  const [cmd, args] = platform() === "darwin" ? ["open", [url]] : platform() === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+  try {
+    spawn(cmd, args, { stdio: "ignore", detached: true }).unref();
+  } catch {
+  }
+}
+async function connect(c) {
+  const device = `${userInfo().username}@${hostname().replace(/\.local$/, "")}`;
+  let start;
+  try {
+    const r = await fetch(`${c.appUrl}/api/runner/link`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ device }) });
+    if (!r.ok) throw new Error(`${r.status}`);
+    start = await r.json();
+  } catch (e) {
+    return fail(`Could not reach ${c.appUrl} (${e.message}). Check your internet connection and try again.`);
+  }
+  say(`${bold("Connect this computer to your Lazy Apply account")}`);
+  say(`Your browser is opening. Check it shows this code, then press ${bold("Connect this computer")}:`);
+  say();
+  say(`    ${bold(teal(start.code))}`);
+  say();
+  say(dim(`If it did not open, go to ${start.url}`));
+  openBrowser(start.url);
+  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  let i = 0;
+  while (Date.now() < start.expiresAt) {
+    if (tty) process.stdout.write(`\r${teal(frames[i++ % frames.length])} Waiting for you to confirm in the browser\u2026`);
+    await new Promise((r) => setTimeout(r, 2e3));
+    try {
+      const r = await fetch(`${c.appUrl}/api/runner/link?secret=${start.secret}`);
+      const d = await r.json();
+      if (d.status === "approved" && d.token) {
+        if (tty) process.stdout.write("\r\x1B[2K");
+        const next = { ...c, token: d.token, account: d.account };
+        save(next);
+        say(`${green("\u2713")} Connected${d.account ? ` as ${bold(d.account)}` : ""}.`);
+        return next;
+      }
+      if (d.status === "expired") break;
+    } catch {
+    }
+  }
+  if (tty) process.stdout.write("\r\x1B[2K");
+  return fail("The code expired before it was confirmed. Run npx lazy-apply again for a new one.");
+}
+function chromeInstalled() {
+  const p = platform();
+  const candidates = p === "darwin" ? ["/Applications/Google Chrome.app", join(homedir(), "Applications/Google Chrome.app")] : p === "win32" ? [process.env["PROGRAMFILES"], process.env["PROGRAMFILES(X86)"], process.env.LOCALAPPDATA].filter(Boolean).map((d) => join(d, "Google/Chrome/Application/chrome.exe")) : ["/usr/bin/google-chrome", "/usr/bin/google-chrome-stable", "/opt/google/chrome/chrome"];
+  return candidates.some((c) => existsSync(c));
+}
+function npxPath() {
+  if (platform() === "win32") return join(dirname(process.execPath), "npx.cmd");
+  const stable = ["/opt/homebrew/bin/npx", "/usr/local/bin/npx", "/usr/bin/npx"].find((p) => existsSync(p));
+  return stable ?? join(dirname(process.execPath), "npx");
+}
+var RUN_ARGS = ["-y", "lazy-apply@latest", "start"];
+function plistPath() {
+  return join(homedir(), "Library/LaunchAgents", `${LABEL}.plist`);
+}
+function unitPath() {
+  return join(homedir(), ".config/systemd/user/lazy-apply.service");
+}
+function startupPath() {
+  return join(process.env.APPDATA || "", "Microsoft/Windows/Start Menu/Programs/Startup/lazy-apply.cmd");
+}
+var xml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+function launchAgentPlist(npx, path, log) {
+  return `<?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>${[npx, ...RUN_ARGS].map((a) => `<string>${xml(a)}</string>`).join("")}</array>
+  <key>EnvironmentVariables</key>
+  <dict><key>PATH</key><string>${xml(path)}</string></dict>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict>
+  <key>ThrottleInterval</key><integer>30</integer>
+  <key>StandardOutPath</key><string>${xml(log)}</string>
+  <key>StandardErrorPath</key><string>${xml(log)}</string>
+</dict>
+</plist>
+`;
+}
+function enableAutostart() {
+  const p = platform();
+  const path = `${dirname(npxPath())}:/opt/homebrew/bin:/usr/local/bin:${dirname(process.execPath)}:/usr/bin:/bin:/usr/sbin:/sbin`;
+  mkdirSync(HOME, { recursive: true });
+  if (p === "darwin") {
+    mkdirSync(dirname(plistPath()), { recursive: true });
+    writeFileSync(plistPath(), launchAgentPlist(npxPath(), path, LOG));
+    const uid = process.getuid?.() ?? 501;
+    try {
+      execFileSync("launchctl", ["bootout", `gui/${uid}/${LABEL}`], { stdio: "ignore" });
+    } catch {
+    }
+    execFileSync("launchctl", ["bootstrap", `gui/${uid}`, plistPath()], { stdio: "ignore" });
+    return "macOS login item";
+  }
+  if (p === "linux") {
+    mkdirSync(dirname(unitPath()), { recursive: true });
+    writeFileSync(unitPath(), `[Unit]
+Description=Lazy Apply runner
+After=graphical-session.target network-online.target
+
+[Service]
+ExecStart=${npxPath()} ${RUN_ARGS.join(" ")}
+Environment=PATH=${path}
+${process.env.DISPLAY ? `Environment=DISPLAY=${process.env.DISPLAY}
+` : ""}${process.env.WAYLAND_DISPLAY ? `Environment=WAYLAND_DISPLAY=${process.env.WAYLAND_DISPLAY}
+` : ""}Restart=on-failure
+RestartSec=30
+StandardOutput=append:${LOG}
+StandardError=append:${LOG}
+
+[Install]
+WantedBy=default.target
+`);
+    execFileSync("systemctl", ["--user", "daemon-reload"], { stdio: "ignore" });
+    execFileSync("systemctl", ["--user", "enable", "--now", "lazy-apply.service"], { stdio: "ignore" });
+    return "systemd user service";
+  }
+  if (p === "win32") {
+    writeFileSync(startupPath(), `@echo off\r
+start "Lazy Apply" /min "${npxPath()}" ${RUN_ARGS.join(" ")}\r
+`);
+    spawn("cmd", ["/c", startupPath()], { detached: true, stdio: "ignore" }).unref();
+    return "Windows startup item";
+  }
+  return fail(`Automatic start is not supported on ${p}. Run npx lazy-apply start yourself instead.`);
+}
+function disableAutostart() {
+  const p = platform();
+  if (p === "darwin") {
+    try {
+      execFileSync("launchctl", ["bootout", `gui/${process.getuid?.() ?? 501}/${LABEL}`], { stdio: "ignore" });
+    } catch {
+    }
+    rmSync(plistPath(), { force: true });
+  } else if (p === "linux") {
+    try {
+      execFileSync("systemctl", ["--user", "disable", "--now", "lazy-apply.service"], { stdio: "ignore" });
+    } catch {
+    }
+    rmSync(unitPath(), { force: true });
+  } else if (p === "win32") rmSync(startupPath(), { force: true });
+}
+var autostartInstalled = () => existsSync(platform() === "darwin" ? plistPath() : platform() === "linux" ? unitPath() : startupPath());
+function runningPid(appUrl) {
+  const lock = join(tmpdir(), `auto-apply-runner-chrome-profile-${appUrl.replace(/[^a-z0-9]+/gi, "_")}.lock`);
+  try {
+    const pid = Number(readFileSync(lock, "utf8"));
+    process.kill(pid, 0);
+    return pid;
+  } catch {
+    return null;
+  }
+}
+async function run(c) {
+  if (!c.token) fail("This computer is not connected yet. Run npx lazy-apply first.");
+  process.env.APP_URL = c.appUrl;
+  process.env.RUNNER_TOKEN = c.token;
+  process.env.RUNNER_PROFILE ||= "chrome-profile";
+  process.env.RUNNER_CLIENT = `lazy-apply-cli/${VERSION} ${platform()}`;
+  say(`${teal("\u25CF")} Lazy Apply runner ${dim(`v${VERSION}`)}${c.account ? ` for ${bold(c.account)}` : ""}. Approved applications fill in a Chrome window. ${dim("Ctrl+C to stop.")}`);
+  await import("./runner.js");
+}
+async function ask(question, yes = true) {
+  if (!process.stdin.isTTY) return false;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const a = (await rl.question(`${question} ${dim(yes ? "[Y/n]" : "[y/N]")} `)).trim().toLowerCase();
+  rl.close();
+  return a ? a.startsWith("y") : yes;
+}
+async function main() {
+  const cmd = process.argv.slice(2).find((a) => !a.startsWith("--") && a !== flag("--app-url")) || "setup";
+  const [major] = process.versions.node.split(".").map(Number);
+  if (major < 18) fail(`Node.js 18 or newer is needed (you have ${process.versions.node}). Install it from https://nodejs.org and try again.`);
+  if (cmd === "help" || process.argv.includes("--help") || process.argv.includes("-h")) {
+    say(`${bold("lazy-apply")} ${dim(`v${VERSION}`)}: fills your approved Lazy Apply applications on this computer.
+`);
+    say(`  npx lazy-apply                  set up (once) and start`);
+    say(`  npx lazy-apply status           what it is doing`);
+    say(`  npx lazy-apply autostart on     start automatically when you log in`);
+    say(`  npx lazy-apply autostart off    stop starting automatically`);
+    say(`  npx lazy-apply start            run now, in this terminal`);
+    say(`  npx lazy-apply logout           disconnect this computer`);
+    return;
+  }
+  if (cmd === "version" || process.argv.includes("--version")) return say(VERSION);
+  let c = load();
+  if (cmd === "start") return run(c);
+  if (cmd === "status") {
+    const pid = runningPid(c.appUrl);
+    say(`${bold("Lazy Apply runner")} ${dim(`v${VERSION}`)}`);
+    say(`  Account          ${c.token ? c.account || "connected" : yellow("not connected (run npx lazy-apply)")}`);
+    say(`  Server           ${c.appUrl}`);
+    say(`  Automatic start  ${autostartInstalled() ? green("on") : "off"}`);
+    say(`  Running          ${pid ? green(`yes (pid ${pid})`) : "no"}`);
+    say(`  Log              ${LOG}`);
+    return;
+  }
+  if (cmd === "autostart") {
+    const on = (process.argv[process.argv.indexOf("autostart") + 1] || "on") !== "off";
+    if (on) {
+      if (!c.token) c = await connect(c);
+      const how = enableAutostart();
+      save({ ...c, autostart: true });
+      say(`${green("\u2713")} Automatic start is on (${how}). It runs in the background whenever you log in.`);
+    } else {
+      disableAutostart();
+      save({ ...c, autostart: false });
+      say(`${green("\u2713")} Automatic start is off.`);
+    }
+    return;
+  }
+  if (cmd === "logout") {
+    disableAutostart();
+    save({ appUrl: c.appUrl, autostart: false });
+    say(`${green("\u2713")} This computer is disconnected and will not start automatically. Run npx lazy-apply to connect again.`);
+    return;
+  }
+  if (cmd !== "setup") fail(`Unknown command "${cmd}". Try npx lazy-apply help.`);
+  say(`${bold(teal("Lazy Apply"))} ${dim(`runner v${VERSION}`)}`);
+  say();
+  if (!c.token) {
+    c = await connect(c);
+    say();
+  } else say(`${green("\u2713")} Connected${c.account ? ` as ${bold(c.account)}` : ""}.`);
+  if (!chromeInstalled()) {
+    say(`${yellow("!")} Google Chrome was not found. The runner fills forms in Chrome, so install it from ${bold("https://www.google.com/chrome/")} and run ${bold("npx lazy-apply")} again.`);
+    process.exit(1);
+  }
+  say(`${green("\u2713")} Google Chrome found.`);
+  const canAutostart = platform() !== "linux" || !!process.env.DISPLAY || !!process.env.WAYLAND_DISPLAY;
+  if (c.autostart === void 0 && canAutostart) {
+    const yes = await ask(`Start automatically in the background whenever you log in? It also keeps itself up to date.`);
+    if (yes) {
+      const how = enableAutostart();
+      save({ ...c, autostart: true });
+      say(`${green("\u2713")} Done (${how}). The runner is now running in the background.`);
+      say(dim(`  It opens a Chrome window only when an approved application needs filling.`));
+      say(dim(`  Check on it any time with npx lazy-apply status. Logs: ${LOG}`));
+      return;
+    }
+    save({ ...c, autostart: false });
+    say(dim(`  No problem. Turn it on later with npx lazy-apply autostart on.`));
+  } else if (c.autostart && autostartInstalled()) {
+    const pid = runningPid(c.appUrl);
+    if (pid) {
+      say(`${green("\u2713")} Already running in the background (pid ${pid}). Nothing else to do.`);
+      return;
+    }
+    enableAutostart();
+    say(`${green("\u2713")} Started it in the background again.`);
+    return;
+  }
+  say();
+  await run(c);
+}
+main().catch((e) => fail(e.message));
+export {
+  launchAgentPlist
+};