@coworker-jp/aidr 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coworker-jp/aidr",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "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.2");
+    .version("0.1.4");
 
   program
     .command("install")

package/src/invoker-resolve.mjs

@@ -0,0 +1,63 @@
+// Best-effort invoker username resolution at install time.
+//
+// `aidr install --scheduled` / `--with-sentinel` writes the unix username
+// into `/etc/aidr/aidr.env` as `AI_SCANNER_INVOKER_USER`. The Rust daemon
+// reads it back to resolve git email / Apple ID / $HOME of the actual
+// installer (root daemons have no useful identity of their own).
+//
+// In the auto-sudo path the CLI re-execs itself via `sudo -E`, which sets
+// SUDO_USER. But several real-world contexts arrive here as bare root
+// without SUDO_USER:
+//   - `ssh root@host` then `npx ... install --scheduled` (no sudo prefix)
+//   - container / CI where the user is already root
+//   - sudo policy that strips SUDO_USER
+//
+// We walk a fallback chain so the resulting daemon snapshot reports the
+// real user instead of `actor_id=unknown`. Each step is best-effort and
+// never throws — we return `null` when no signal is available, which is
+// the honest outcome for genuinely identity-less contexts (CI runners).
+
+import { execSync } from "node:child_process";
+
+function tryExec(cmd) {
+  try {
+    return execSync(cmd, { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+  } catch {
+    return "";
+  }
+}
+
+function isUsable(name) {
+  return name && name !== "root";
+}
+
+export function resolveInvokerUser() {
+  if (process.env.SUDO_USER) return process.env.SUDO_USER;
+
+  // `who am i` reads utmp, so it returns the actual login user even after
+  // `sudo -i` / `su -`. Empty under non-tty / no utmp.
+  const whoUser = tryExec("who am i").split(/\s+/)[0];
+  if (isUsable(whoUser)) return whoUser;
+
+  // POSIX `logname` gives controlling-tty owner. Slightly different code
+  // path from `who am i` — kept as a separate fallback because they fail
+  // independently on minimal images.
+  const logname = tryExec("logname");
+  if (isUsable(logname)) return logname;
+
+  // systemd Linux: `loginctl list-sessions` columns are: SESSION UID USER ...
+  const loginctl = tryExec("loginctl list-sessions --no-legend");
+  for (const line of loginctl.split("\n")) {
+    const fields = line.trim().split(/\s+/);
+    if (fields.length >= 3 && isUsable(fields[2])) return fields[2];
+  }
+
+  // Env fallbacks (root-filtered) so a user-shell install without sudo at
+  // all (rare for --scheduled, possible for plain --agent without root)
+  // still captures the obvious answer.
+  for (const env of ["LOGNAME", "USER"]) {
+    if (isUsable(process.env[env])) return process.env[env];
+  }
+
+  return null;
+}

package/src/scheduled.mjs

@@ -2,6 +2,7 @@ import fs from "fs/promises";
 import path from "path";
 import { execFile } from "child_process";
 import { promisify } from "util";
+import { resolveInvokerUser } from "./invoker-resolve.mjs";
 
 const execFileP = promisify(execFile);
 
@@ -21,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");
@@ -133,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) {
@@ -161,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 });
@@ -177,14 +166,14 @@ export async function installScheduled(opts) {
 }
 
 async function writeEnvFile(accessKey, dryRun) {
-  // Capture only the SUDO_USER (the unix username of whoever ran
-  // `sudo aidr install ...`) — the Rust binary will resolve the full
-  // identity (Apple ID / git email / username) at scan time using
-  // `sudo -u <invoker>` so it reads the invoker's plist / gitconfig
-  // instead of root's empty ones. Pre-resolving here is the wrong
-  // layer because the Apple ID needs to be re-read in the right user
-  // context at runtime anyway (root has no MobileMeAccounts.plist).
-  const invoker = process.env.SUDO_USER || null;
+  // Capture the invoker username (SUDO_USER first, then `who am i` /
+  // `logname` / `loginctl` / $LOGNAME / $USER fallbacks) — the Rust
+  // binary resolves the full identity (Apple ID / git email / username)
+  // at scan time using `sudo -u <invoker>` so it reads the invoker's
+  // plist / gitconfig instead of root's empty ones. Pre-resolving here
+  // is the wrong layer because the Apple ID needs to be re-read in the
+  // right user context at runtime anyway (root has no MobileMeAccounts).
+  const invoker = resolveInvokerUser();
   let envContent = `AI_SCANNER_ACCESS_KEY=${accessKey}\n`;
   if (invoker) envContent += `AI_SCANNER_INVOKER_USER=${invoker}\n`;
   if (dryRun) {
@@ -196,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
@@ -317,7 +255,7 @@ 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).
+  // sudo.
   const entry = `0 */${interval} * * * root . ${SYSTEM_ENV_FILE} && ${binaryPath} scan endpoint-info >> ${SCHEDULED_LOG_FILE} 2>&1 # aidr-scheduled
 `;
   if (dryRun) {
@@ -327,6 +265,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 } = {}) {
@@ -336,16 +290,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 */ }
@@ -363,8 +307,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); }

package/src/sentinel.mjs

@@ -13,6 +13,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { execFile, spawnSync } from "node:child_process";
+import { resolveInvokerUser } from "./invoker-resolve.mjs";
 import { promisify } from "node:util";
 import { fetchSentinel, detectPlatform } from "./binary-fetcher.mjs";
 import {
@@ -155,7 +156,7 @@ export async function installSentinel(opts = {}) {
       appended += `\nAI_SCANNER_ACCESS_KEY=${accessKey}\n`;
     }
     if (!content.includes("AI_SCANNER_INVOKER_USER")) {
-      const invoker = process.env.SUDO_USER;
+      const invoker = resolveInvokerUser();
       if (invoker) {
         appended += `AI_SCANNER_INVOKER_USER=${invoker}\n`;
       }