@coworker-jp/aidr 0.1.3 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coworker-jp/aidr",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "AIDR setup CLI - installs ai-scanner hooks for 19+ AI coding agents",
   "type": "module",
   "bin": {

package/src/cli.mjs

@@ -589,7 +589,7 @@ export async function run(argv) {
   program
     .name("aidr")
     .description("AIDR setup CLI — installs ai-scanner hooks for AI coding agents")
-    .version("0.1.3");
+    .version("0.1.5");
 
   program
     .command("install")

package/src/scheduled.mjs

@@ -22,24 +22,19 @@ export const SYSTEM_USR_LOCAL_BIN = ROOT_PREFIX + "/usr/local/bin/ai-scanner";
 const SYSTEM_ENV_DIR            = ROOT_PREFIX + "/etc/aidr";
 export const SYSTEM_ENV_FILE    = path.join(SYSTEM_ENV_DIR, "aidr.env");
 
-// Linux systemd
-const SYSTEMD_DIR             = ROOT_PREFIX + "/etc/systemd/system";
-export const SYSTEMD_SERVICE  = path.join(SYSTEMD_DIR, "aidr-scheduled.service");
-export const SYSTEMD_TIMER    = path.join(SYSTEMD_DIR, "aidr-scheduled.timer");
-
 // macOS launchd (LaunchDaemons run as root, available pre-login)
 export const LAUNCHD_PLIST    = ROOT_PREFIX + "/Library/LaunchDaemons/jp.coworker.aidr.scheduled.plist";
 export const LAUNCHD_WRAPPER  = path.join(SYSTEM_BIN_DIR, "aidr-scheduled-wrapper.sh");
 
-// Linux cron fallback (system cron, runs as root)
+// Linux: cron.d entry, runs as root every N hours.
 export const CRON_FILE        = ROOT_PREFIX + "/etc/cron.d/aidr-scheduled";
 
 // Shared world-readable system log directory. Both aidr-scheduled and
 // coworker-sentinel daemons write here so non-root users can `tail` errors
 // without sudo (memory: feedback_server_failures_never_burden_client.md).
-// Mode 0755 root:root, files mode 0644. systemd's `StandardOutput=append:`
-// (systemd 240+) and launchd's `StandardOutPath` redirect daemon stderr/stdout
-// here; for cron, the entry uses a literal `>> ... 2>&1` redirect.
+// Mode 0755 root:root, files mode 0644. launchd's `StandardOutPath` (macOS)
+// redirects daemon stderr/stdout here; for Linux cron, the entry uses a
+// literal `>> ... 2>&1` redirect.
 export const SYSTEM_LOG_DIR     = ROOT_PREFIX + "/var/log/coworker";
 export const SCHEDULED_LOG_FILE = path.join(SYSTEM_LOG_DIR, "scheduled.log");
 export const SENTINEL_LOG_FILE  = path.join(SYSTEM_LOG_DIR, "sentinel.log");
@@ -134,11 +129,7 @@ export async function removeSystemLog(logFile, { dryRun = false } = {}) {
 }
 
 export async function isScheduledInstalled() {
-  return (
-    await exists(SYSTEMD_TIMER) ||
-    await exists(LAUNCHD_PLIST) ||
-    await exists(CRON_FILE)
-  );
+  return (await exists(LAUNCHD_PLIST)) || (await exists(CRON_FILE));
 }
 
 export async function installScheduled(opts) {
@@ -162,15 +153,12 @@ export async function installScheduled(opts) {
   await writeEnvFile(accessKey, dryRun);
 
   // Create the world-readable log dir + touch scheduled.log + drop the
-  // shared logrotate config. Both run before the systemd / launchd / cron
-  // entry so the daemon's first invocation has a target to append to.
+  // shared logrotate config. Both run before the launchd / cron entry so
+  // the daemon's first invocation has a target to append to.
   await ensureSystemLogDir(SCHEDULED_LOG_FILE, { dryRun });
   await writeLogrotateConfig({ dryRun });
 
-  const platform = process.platform;
-  if (platform === "linux") {
-    await installSystemd({ dryRun, noActivate, interval, binaryPath });
-  } else if (platform === "darwin") {
+  if (process.platform === "darwin") {
     await installLaunchd({ dryRun, noActivate, interval, binaryPath });
   } else {
     await installCronDir({ binaryPath, dryRun, interval });
@@ -197,57 +185,6 @@ async function writeEnvFile(accessKey, dryRun) {
   await fs.writeFile(SYSTEM_ENV_FILE, envContent, { mode: 0o600 });
 }
 
-async function installSystemd({ binaryPath, dryRun, noActivate, interval = 4 }) {
-  // StandardOutput=append: requires systemd 240+ (released 2018). Modern
-  // distros (RHEL 9 / Ubuntu 20.04+ / Debian 11+) all support it. Older
-  // RHEL 8 (systemd 239) operators must redirect manually or upgrade.
-  const serviceContent = `[Unit]
-Description=AIDR scheduled endpoint-info scan
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=oneshot
-User=root
-EnvironmentFile=${SYSTEM_ENV_FILE}
-ExecStart=${binaryPath} scan endpoint-info
-StandardOutput=append:${SCHEDULED_LOG_FILE}
-StandardError=append:${SCHEDULED_LOG_FILE}
-`;
-
-  const timerContent = `[Unit]
-Description=AIDR scheduled endpoint-info scan timer
-
-[Timer]
-OnBootSec=5min
-OnUnitActiveSec=${interval}h
-Persistent=true
-
-[Install]
-WantedBy=timers.target
-`;
-
-  if (dryRun) {
-    console.log("[dry-run] Would create:", SYSTEMD_SERVICE, SYSTEMD_TIMER);
-    return;
-  }
-
-  await fs.mkdir(path.dirname(SYSTEMD_SERVICE), { recursive: true });
-  await fs.writeFile(SYSTEMD_SERVICE, serviceContent, { mode: 0o644 });
-  await fs.writeFile(SYSTEMD_TIMER, timerContent, { mode: 0o644 });
-
-  if (!noActivate) {
-    try {
-      await execFileP("systemctl", ["daemon-reload"]);
-      await execFileP("systemctl", ["enable", "--now", "aidr-scheduled.timer"]);
-      console.log(`Scheduled scan enabled via system systemd timer (every ${interval}h)`);
-    } catch (e) {
-      console.warn("Warning: systemctl failed:", e.message);
-      console.warn("Timer files were written. Enable manually: sudo systemctl enable --now aidr-scheduled.timer");
-    }
-  }
-}
-
 export async function installLaunchd({ binaryPath, dryRun, noActivate, interval = 4 }) {
   // launchd does not support EnvironmentFile, so we use a tiny wrapper that
   // sources /etc/aidr/aidr.env and execs the binary. Plist itself stays 0644
@@ -315,11 +252,13 @@ exec ${binaryPath} scan endpoint-info
 }
 
 async function installCronDir({ binaryPath, dryRun, interval = 4 }) {
-  // /etc/cron.d entries run as the user named in the line. We embed the env
-  // file source via a small inline script. stdout + stderr are appended to
-  // the world-readable log so non-root users can read recent runs without
-  // sudo (replaces the old `2>/dev/null` which deliberately swallowed errors).
-  const entry = `0 */${interval} * * * root . ${SYSTEM_ENV_FILE} && ${binaryPath} scan endpoint-info >> ${SCHEDULED_LOG_FILE} 2>&1 # aidr-scheduled
+  // The aidr.env file is plain `KEY=VALUE` lines (no `export` prefix —
+  // systemd's EnvironmentFile= used by the sentinel service requires that
+  // form). Plain `. file` sets shell-local variables that don't propagate
+  // to the spawned ai-scanner process; `set -a` flips on auto-export so
+  // every assignment becomes an environment variable. Same pattern as the
+  // launchd wrapper on macOS.
+  const entry = `0 */${interval} * * * root set -a; . ${SYSTEM_ENV_FILE}; set +a; ${binaryPath} scan endpoint-info >> ${SCHEDULED_LOG_FILE} 2>&1
 `;
   if (dryRun) {
     console.log("[dry-run] Would create:", CRON_FILE);
@@ -328,6 +267,22 @@ async function installCronDir({ binaryPath, dryRun, interval = 4 }) {
   await fs.mkdir(path.dirname(CRON_FILE), { recursive: true });
   await fs.writeFile(CRON_FILE, entry, { mode: 0o644 });
   console.log(`Scheduled scan added to ${CRON_FILE} (every ${interval}h)`);
+
+  // Warn (don't fail) when no cron daemon is detected. The file is valid;
+  // the user just needs to install one (`apt install cron`, `dnf install
+  // cronie`, etc.) before the next scheduled hour for it to fire.
+  if (!await hasCronDaemon()) {
+    console.warn(
+      "WARNING: cron daemon not detected. Install one (`apt install cron` / `dnf install cronie` / `apk add dcron`) so /etc/cron.d/aidr-scheduled actually fires."
+    );
+  }
+}
+
+async function hasCronDaemon() {
+  for (const candidate of ["/usr/sbin/cron", "/usr/sbin/crond", "/sbin/cron", "/sbin/crond"]) {
+    if (await exists(candidate)) return true;
+  }
+  return false;
 }
 
 export async function uninstallScheduled({ dryRun = false, noActivate = false } = {}) {
@@ -337,16 +292,6 @@ export async function uninstallScheduled({ dryRun = false, noActivate = false }
     throw new Error("uninstallScheduled requires root privileges");
   }
 
-  if (await exists(SYSTEMD_TIMER)) {
-    if (!dryRun && !noActivate) {
-      try { await execFileP("systemctl", ["disable", "--now", "aidr-scheduled.timer"]); } catch { /* ignore */ }
-    }
-    for (const f of [SYSTEMD_SERVICE, SYSTEMD_TIMER]) {
-      if (!dryRun) { try { await fs.unlink(f); } catch { /* ignore */ } }
-      else { console.log("[dry-run] Would remove:", f); }
-    }
-  }
-
   if (await exists(LAUNCHD_PLIST)) {
     if (!dryRun && !noActivate) {
       try { await execFileP("launchctl", ["bootout", "system", LAUNCHD_PLIST]); } catch { /* ignore */ }
@@ -364,8 +309,8 @@ export async function uninstallScheduled({ dryRun = false, noActivate = false }
     else { console.log("[dry-run] Would remove:", CRON_FILE); }
   }
 
-  // Remove the env file last so an aborted uninstall (mid-systemctl) doesn't
-  // strand a service file that still references a missing env file.
+  // Remove the env file last so an aborted uninstall doesn't strand a
+  // schedule entry that still references a missing env file.
   if (await exists(SYSTEM_ENV_FILE)) {
     if (!dryRun) { try { await fs.unlink(SYSTEM_ENV_FILE); } catch { /* ignore */ } }
     else { console.log("[dry-run] Would remove:", SYSTEM_ENV_FILE); }