@coworker-jp/aidr 0.0.2 → 0.0.4

package/package.json

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

package/src/binary-fetcher.mjs

@@ -155,3 +155,35 @@ export async function fetchOpengrep(destPath) {
 
   return { path: destPath, platform, sha256, verified: true };
 }
+
+/**
+ * Download coworker-sentinel for the current platform into `destPath`.
+ * Uses the presigned S3 URL from the verify response when available,
+ * otherwise falls back to the licensed download endpoint.
+ * Returns { path, platform, sha256, verified }.
+ */
+export async function fetchSentinel(destPath, { accessKey, presignedUrl, env = "prod" } = {}) {
+  const platform = detectPlatform();
+
+  let binUrl;
+  if (presignedUrl) {
+    // Use presigned URL from verify response (no auth header needed)
+    binUrl = presignedUrl;
+    accessKey = undefined;
+  } else {
+    const base = downloadBase(env);
+    binUrl = `${base}/sentinel/${platform}`;
+  }
+
+  await fsp.mkdir(path.dirname(destPath), { recursive: true });
+  const buf = await fetchBuffer(binUrl, accessKey);
+  const sha256 = crypto.createHash("sha256").update(buf).digest("hex");
+
+  const tmp = `${destPath}.tmp-${process.pid}`;
+  await fsp.writeFile(tmp, buf);
+  await fsp.chmod(tmp, 0o755);
+  await fsp.rename(tmp, destPath);
+  await clearQuarantine(destPath);
+
+  return { path: destPath, platform, sha256, verified: false };
+}

package/src/cli.mjs

@@ -13,6 +13,7 @@ import { verifyKey, maskKey } from "./verify.mjs";
 import { fetchBinary, fetchOpengrep } from "./binary-fetcher.mjs";
 import { detectInstalled } from "./detect.mjs";
 import { installBrowserExtension } from "./browser-extension.mjs";
+import { resolveCallerHome, isRunningUnderSudo, chownToCaller } from "./sudo-user.mjs";
 
 // Package identity — read at module load from the bundled package.json.
 // The PROD publish workflow renames the package to `@coworker-jp/aidr`;
@@ -83,21 +84,47 @@ async function cmdInstall(opts) {
     });
   }
 
-  const home = process.env.HOME || os.homedir();
+  const home = resolveCallerHome();
   const scope = opts.scope || "user";
   const base = scope === "user" ? home : process.cwd();
   validateKey(opts.key);
 
+  let verifyInfo = null;
   if (opts.verify !== false) {
     try {
-      const info = await verifyKey(opts.key, opts.env || DEFAULT_ENV);
-      console.log(`verified: plan=${info.plan} expires_at=${info.expires_at || "n/a"}`);
+      verifyInfo = await verifyKey(opts.key, opts.env || DEFAULT_ENV);
     } catch (e) {
       console.error(`verify failed: ${e.message}`);
       process.exit(1);
     }
   }
 
+  // --with-sentinel requires pro or trial plan
+  if (opts.withSentinel && verifyInfo && !verifyInfo.edr_enabled) {
+    console.error("Error: --with-sentinel requires a Pro or Trial plan.");
+    console.error(`Current plan: ${verifyInfo.plan}`);
+    process.exit(1);
+  }
+
+  // --with-sentinel requires root (same as --scheduled)
+  if (opts.withSentinel && !opts.dryRun
+      && process.getuid && process.getuid() !== 0
+      && process.env.AI_SCANNER_FAKE_ROOT !== "1") {
+    const interactive = process.stdin.isTTY && process.stdout.isTTY && process.platform !== "win32";
+    if (interactive) {
+      console.error("--with-sentinel requires root. Re-running via sudo (you may be prompted for your password)...");
+      const result = spawnSync(
+        "sudo",
+        ["-E", process.execPath, ...process.argv.slice(1)],
+        { stdio: "inherit" }
+      );
+      process.exit(result.status ?? 1);
+    }
+    console.error("Error: --with-sentinel requires root privileges.");
+    console.error(`  sudo -E npx @coworker-jp/aidr install --with-sentinel --key <ak_xxx>`);
+    process.exit(2);
+  }
+
   let agents;
   if (opts.all) {
     agents = detectInstalled(home);
@@ -245,8 +272,6 @@ async function cmdInstall(opts) {
           })
         );
         await Promise.all(copyOps);
-
-        console.log("Includes Opengrep (LGPL-2.1).");
       } catch (e) {
         console.error(`binary fetch failed: ${e.message}`);
         if (!opts.binaryOnly) console.error("continuing with hook install (use --skip-binary to suppress)");
@@ -297,6 +322,25 @@ async function cmdInstall(opts) {
     }
   }
 
+  if (opts.withSentinel) {
+    const { installSentinel } = await import("./sentinel.mjs");
+    try {
+      const platform = (await import("./binary-fetcher.mjs")).detectPlatform();
+      const presignedUrl = verifyInfo?.sentinel_download_urls?.[platform] || undefined;
+      await installSentinel({
+        accessKey: opts.key,
+        dryRun: opts.dryRun,
+        skipBinary: opts.skipBinary,
+        presignedUrl,
+        env: opts.env || DEFAULT_ENV,
+        noActivate: process.env.AI_SCANNER_NO_SCHEDULED_ACTIVATE === "1",
+      });
+    } catch (e) {
+      console.error(`sentinel install failed: ${e.message}`);
+      process.exit(1);
+    }
+  }
+
   if (opts.browserExtension && !opts.dryRun) {
     const firstAgentName = agents[0];
     const firstAgent = await loadAgent(firstAgentName);
@@ -308,6 +352,19 @@ async function cmdInstall(opts) {
     }
   }
 
+  // Auto-sudo re-exec wrote per-agent files as root into the original user's
+  // home / cwd. Hand them back so the user can manage them without sudo on
+  // subsequent runs. System-wide writes under /opt + /etc are intentionally
+  // left root-owned by skipping anything outside `base`.
+  if (isRunningUnderSudo() && !opts.dryRun) {
+    for (const r of installResults) {
+      const mod = await loadAgent(r.name);
+      const agentDir = mod.meta.agentDir;
+      if (!agentDir) continue;
+      await chownToCaller(path.join(base, agentDir));
+    }
+  }
+
   if (restartAgents.length > 0 && !opts.dryRun) {
     const list = restartAgents.join(", ");
     console.log("");
@@ -320,7 +377,7 @@ async function cmdInstall(opts) {
 }
 
 async function cmdUninstall(opts) {
-  const home = process.env.HOME || os.homedir();
+  const home = resolveCallerHome();
   const scope = opts.scope || "user";
   const base = scope === "user" ? home : process.cwd();
 
@@ -466,7 +523,7 @@ async function cmdUninstall(opts) {
 }
 
 async function cmdDoctor() {
-  const home = process.env.HOME || os.homedir();
+  const home = resolveCallerHome();
   console.log(`home: ${home}`);
   console.log(`node: ${process.version}`);
   console.log(`platform: ${process.platform}/${process.arch}`);
@@ -503,7 +560,7 @@ export async function run(argv) {
   program
     .name("aidr")
     .description("AIDR setup CLI — installs ai-scanner hooks for AI coding agents")
-    .version("0.0.2");
+    .version("0.0.4");
 
   program
     .command("install")
@@ -522,6 +579,7 @@ export async function run(argv) {
     .option("--uninstall", "remove all ai-scanner hooks/scripts/binaries for the selected agents (see 'uninstall' command)", false)
     .option("--scheduled", "enable scheduled endpoint-info collection (creates a cron/systemd/launchd entry; without this flag endpoint-info is never collected)", false)
     .option("--interval <hours>", "scheduled scan interval in hours (min 1, default 4; requires --scheduled)", "4")
+    .option("--with-sentinel", "install coworker-sentinel host-level EDR daemon (Pro/Trial plan; requires sudo)", false)
     .option("--browser-extension", "install browser extension native messaging host for Shadow IT network monitoring (default: disabled)", false)
     .action(cmdInstall);
 

package/src/sentinel.mjs

@@ -0,0 +1,239 @@
+/**
+ * coworker-sentinel install/uninstall helpers.
+ *
+ * Requires root (sudo -E) because the daemon runs as a LaunchDaemon (macOS)
+ * or systemd service (Linux) to monitor OS-level events system-wide.
+ *
+ * Install paths (shared with scheduled.mjs):
+ *   Binary:  /opt/coworker/aidr/bin/coworker-sentinel
+ *   macOS:   /Library/LaunchDaemons/jp.coworker.sentinel.plist
+ *   Linux:   /etc/systemd/system/coworker-sentinel.service
+ *   Env:     /etc/aidr/aidr.env  (shared with scheduler)
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile, spawnSync } from "node:child_process";
+import { promisify } from "node:util";
+import { fetchSentinel, detectPlatform } from "./binary-fetcher.mjs";
+import { SYSTEM_BIN_DIR, SYSTEM_ENV_FILE } from "./scheduled.mjs";
+
+const execFileP = promisify(execFile);
+
+const ROOT_PREFIX = process.env.AIDR_SCHEDULED_ROOT || "";
+
+export const SENTINEL_BIN = path.join(SYSTEM_BIN_DIR, "coworker-sentinel");
+export const SENTINEL_PLIST = ROOT_PREFIX + "/Library/LaunchDaemons/jp.coworker.sentinel.plist";
+export const SENTINEL_SERVICE = ROOT_PREFIX + "/etc/systemd/system/coworker-sentinel.service";
+export const SENTINEL_LOG_DIR = ROOT_PREFIX + "/var/log/coworker-sentinel";
+
+function isRoot() {
+  if (process.env.AI_SCANNER_FAKE_ROOT === "1") return true;
+  return Boolean(process.getuid && process.getuid() === 0);
+}
+
+async function exists(p) {
+  try { await fs.access(p); return true; } catch { return false; }
+}
+
+export async function isSentinelInstalled() {
+  return (
+    (await exists(SENTINEL_PLIST)) ||
+    (await exists(SENTINEL_SERVICE))
+  );
+}
+
+function buildLaunchdPlist(envFile) {
+  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>jp.coworker.sentinel</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/bin/sh</string>
+    <string>-c</string>
+    <string>. ${envFile} &amp;&amp; exec ${SENTINEL_BIN}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${SENTINEL_LOG_DIR}/sentinel.log</string>
+  <key>StandardErrorPath</key>
+  <string>${SENTINEL_LOG_DIR}/sentinel.log</string>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+</dict>
+</plist>
+`;
+}
+
+function buildSystemdService(envFile) {
+  return `[Unit]
+Description=coworker-sentinel Host EDR Daemon
+After=network.target
+StartLimitIntervalSec=60
+StartLimitBurst=5
+
+[Service]
+Type=simple
+EnvironmentFile=${envFile}
+ExecStart=${SENTINEL_BIN}
+Restart=on-failure
+RestartSec=5
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=coworker-sentinel
+
+[Install]
+WantedBy=multi-user.target
+`;
+}
+
+/**
+ * Install the sentinel daemon.
+ *
+ * opts:
+ *   accessKey    — ak_xxx  (written to env file if not already present)
+ *   dryRun       — log actions without executing
+ *   noActivate   — skip launchctl/systemctl activation
+ *   presignedUrl — presigned S3 URL from verify response (optional)
+ *   env          — "dev" | "prod"
+ */
+export async function installSentinel(opts = {}) {
+  const { accessKey, dryRun = false, skipBinary = false, noActivate = false, presignedUrl, env = "prod" } = opts;
+
+  if (!isRoot()) {
+    throw new Error(
+      "installSentinel requires root privileges.\n" +
+      "Re-run with: sudo -E npx @coworker-jp/aidr install --key <key> --with-sentinel"
+    );
+  }
+
+  const platform = detectPlatform();
+  console.error(`[sentinel] Installing coworker-sentinel for ${platform}…`);
+
+  // 1. Download binary
+  if (!dryRun && !skipBinary) {
+    await fs.mkdir(SYSTEM_BIN_DIR, { recursive: true });
+    console.error(`[sentinel] Downloading binary → ${SENTINEL_BIN}`);
+    await fetchSentinel(SENTINEL_BIN, { accessKey, presignedUrl, env });
+  } else if (skipBinary) {
+    console.error(`[sentinel] Skipping binary download (--skip-binary)`);
+  } else {
+    console.error(`[sentinel] DRY-RUN: would download → ${SENTINEL_BIN}`);
+  }
+
+  // 2. Create log directory
+  if (!dryRun) {
+    await fs.mkdir(SENTINEL_LOG_DIR, { recursive: true, mode: 0o755 });
+  }
+
+  // 3. Write env file (append AI_SCANNER_ACCESS_KEY if missing)
+  if (accessKey && !dryRun) {
+    let content = "";
+    try { content = await fs.readFile(SYSTEM_ENV_FILE, "utf8"); } catch { /* first run */ }
+    if (!content.includes("AI_SCANNER_ACCESS_KEY")) {
+      await fs.mkdir(path.dirname(SYSTEM_ENV_FILE), { recursive: true });
+      await fs.appendFile(SYSTEM_ENV_FILE, `\nAI_SCANNER_ACCESS_KEY=${accessKey}\n`);
+      await fs.chmod(SYSTEM_ENV_FILE, 0o600);
+    }
+  }
+
+  // 4. Write service/plist
+  if (process.platform === "darwin") {
+    await _installMacos(dryRun, noActivate);
+  } else {
+    await _installLinux(dryRun, noActivate);
+  }
+
+  console.error("[sentinel] Installation complete.");
+}
+
+async function _installMacos(dryRun, noActivate) {
+  const plistContent = buildLaunchdPlist(SYSTEM_ENV_FILE);
+  if (!dryRun) {
+    await fs.mkdir(path.dirname(SENTINEL_PLIST), { recursive: true });
+    await fs.writeFile(SENTINEL_PLIST, plistContent, { mode: 0o644 });
+    console.error(`[sentinel] Written: ${SENTINEL_PLIST}`);
+
+    if (!noActivate && process.env.AI_SCANNER_NO_SCHEDULED_ACTIVATE !== "1") {
+      // Unload existing (ignore errors) then load
+      spawnSync("launchctl", ["unload", SENTINEL_PLIST], { stdio: "ignore" });
+      const load = spawnSync("launchctl", ["load", "-w", SENTINEL_PLIST]);
+      if (load.status !== 0) {
+        console.warn("[sentinel] launchctl load failed — daemon may need manual start");
+      } else {
+        console.error("[sentinel] Daemon loaded via launchctl");
+      }
+    }
+  } else {
+    console.error(`[sentinel] DRY-RUN: would write ${SENTINEL_PLIST}`);
+  }
+}
+
+async function _installLinux(dryRun, noActivate) {
+  const serviceContent = buildSystemdService(SYSTEM_ENV_FILE);
+  const serviceDir = path.dirname(SENTINEL_SERVICE);
+  if (!dryRun) {
+    await fs.mkdir(serviceDir, { recursive: true });
+    await fs.writeFile(SENTINEL_SERVICE, serviceContent, { mode: 0o644 });
+    console.error(`[sentinel] Written: ${SENTINEL_SERVICE}`);
+
+    if (!noActivate && process.env.AI_SCANNER_NO_SCHEDULED_ACTIVATE !== "1") {
+      spawnSync("systemctl", ["daemon-reload"], { stdio: "ignore" });
+      spawnSync("systemctl", ["enable", "--now", "coworker-sentinel"], { stdio: "ignore" });
+      console.error("[sentinel] Enabled and started via systemctl");
+    }
+  } else {
+    console.error(`[sentinel] DRY-RUN: would write ${SENTINEL_SERVICE}`);
+  }
+}
+
+/**
+ * Uninstall the sentinel daemon.
+ */
+export async function uninstallSentinel({ dryRun = false } = {}) {
+  if (!isRoot()) {
+    throw new Error("uninstallSentinel requires root privileges.");
+  }
+
+  console.error("[sentinel] Uninstalling coworker-sentinel…");
+
+  if (process.platform === "darwin") {
+    if (await exists(SENTINEL_PLIST)) {
+      if (!dryRun) {
+        spawnSync("launchctl", ["unload", SENTINEL_PLIST], { stdio: "ignore" });
+        await fs.unlink(SENTINEL_PLIST);
+        console.error(`[sentinel] Removed: ${SENTINEL_PLIST}`);
+      } else {
+        console.error(`[sentinel] DRY-RUN: would remove ${SENTINEL_PLIST}`);
+      }
+    }
+  } else {
+    if (await exists(SENTINEL_SERVICE)) {
+      if (!dryRun) {
+        spawnSync("systemctl", ["disable", "--now", "coworker-sentinel"], { stdio: "ignore" });
+        await fs.unlink(SENTINEL_SERVICE);
+        spawnSync("systemctl", ["daemon-reload"], { stdio: "ignore" });
+        console.error(`[sentinel] Removed: ${SENTINEL_SERVICE}`);
+      } else {
+        console.error(`[sentinel] DRY-RUN: would remove ${SENTINEL_SERVICE}`);
+      }
+    }
+  }
+
+  if (await exists(SENTINEL_BIN)) {
+    if (!dryRun) {
+      await fs.unlink(SENTINEL_BIN);
+      console.error(`[sentinel] Removed: ${SENTINEL_BIN}`);
+    } else {
+      console.error(`[sentinel] DRY-RUN: would remove ${SENTINEL_BIN}`);
+    }
+  }
+
+  console.error("[sentinel] Uninstall complete.");
+}

package/src/sudo-user.mjs

@@ -0,0 +1,111 @@
+// SUDO_USER-aware HOME resolution and ownership helpers.
+//
+// `aidr install --scheduled` auto-escalates via `sudo -E` (cli.mjs).
+// After sudo, the new node process runs as root with HOME reset to /root by
+// the default `set_home` policy. Without correction, every path derived from
+// HOME (e.g. ~/.claude/settings.json under `--scope user`) would land in
+// /root instead of the original user's home, AND every file we write would
+// be root-owned even though the user expects to manage them.
+//
+// We restore the caller's identity via the SUDO_USER / SUDO_UID / SUDO_GID
+// vars sudo always sets, and chown the user-scope writes back to that user
+// when the install completes.
+
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { execFileSync } from "node:child_process";
+
+/**
+ * Look up `username`'s home directory.
+ * 1. /etc/passwd  (Linux always; macOS for system users only)
+ * 2. macOS dscl   (regular macOS users live in Open Directory)
+ * Returns null if not found.
+ *
+ * Test override: AIDR_PASSWD_FILE points at an alternate passwd-format file.
+ */
+export function lookupUserHome(username) {
+  if (!username) return null;
+  const passwdPath = process.env.AIDR_PASSWD_FILE || "/etc/passwd";
+  try {
+    const passwd = fs.readFileSync(passwdPath, "utf8");
+    for (const line of passwd.split("\n")) {
+      const f = line.split(":");
+      if (f[0] === username && f[5]) return f[5];
+    }
+  } catch { /* fall through */ }
+
+  if (process.platform === "darwin" && !process.env.AIDR_PASSWD_FILE) {
+    try {
+      const out = execFileSync(
+        "dscl", [".", "-read", `/Users/${username}`, "NFSHomeDirectory"],
+        { encoding: "utf8", timeout: 2000 }
+      );
+      const m = out.match(/NFSHomeDirectory:\s*(.+)/);
+      if (m) return m[1].trim();
+    } catch { /* fall through */ }
+  }
+  return null;
+}
+
+/**
+ * Resolve the calling user's home.
+ * - If running as root with SUDO_USER set, use SUDO_USER's home (auto-sudo case).
+ * - Otherwise fall back to $HOME / os.homedir().
+ *
+ * Test override: AIDR_FORCE_HOME bypasses everything.
+ */
+export function resolveCallerHome() {
+  if (process.env.AIDR_FORCE_HOME) return process.env.AIDR_FORCE_HOME;
+  if (isRunningUnderSudo()) {
+    const sudoHome = lookupUserHome(process.env.SUDO_USER);
+    if (sudoHome) return sudoHome;
+  }
+  return process.env.HOME || os.homedir();
+}
+
+/**
+ * True when we're running as root *and* SUDO_USER is set — i.e. the auto-sudo
+ * re-exec path. Plain `su` or login-as-root sets neither, and is treated as
+ * intentional root usage (no chown back).
+ */
+export function isRunningUnderSudo() {
+  if (process.platform === "win32") return false;
+  if (!process.getuid || process.getuid() !== 0) return false;
+  return Boolean(process.env.SUDO_USER);
+}
+
+/**
+ * SUDO_UID / SUDO_GID parsed as integers, or null when not under sudo.
+ */
+export function callerIds() {
+  if (!isRunningUnderSudo()) return null;
+  const uid = parseInt(process.env.SUDO_UID || "", 10);
+  const gid = parseInt(process.env.SUDO_GID || "", 10);
+  if (Number.isInteger(uid) && Number.isInteger(gid)) return { uid, gid };
+  return null;
+}
+
+/**
+ * Recursively chown a path tree to the caller (SUDO_USER) when running under
+ * auto-sudo. No-op when not under sudo or on Windows. Errors per-entry are
+ * swallowed — worst case the user fixes ownership manually with a single
+ * `chown -R`. Symlinks are chowned via lchown (don't follow).
+ */
+export async function chownToCaller(targetPath) {
+  const ids = callerIds();
+  if (!ids) return;
+  await chownTree(targetPath, ids.uid, ids.gid);
+}
+
+async function chownTree(p, uid, gid) {
+  let st;
+  try { st = await fsp.lstat(p); } catch { return; }
+  try { await fsp.lchown(p, uid, gid); } catch { /* ignore */ }
+  if (st.isDirectory()) {
+    let entries;
+    try { entries = await fsp.readdir(p); } catch { return; }
+    await Promise.all(entries.map((e) => chownTree(path.join(p, e), uid, gid)));
+  }
+}

package/src/templates.mjs

@@ -1,7 +1,7 @@
-// SOURCE: docker/user-frontend/src/lib/scanner-templates.ts
-// ESM port of the scanner hook templates. Keep in sync with the TS source.
-// Templates are byte-identical to the canonical .{agent}/ files in ai-scanner
-// repo (Claude / Cursor / Windsurf / Kiro) — only the access key value differs.
+// Canonical source for the scanner hook templates installed by aidr.
+// Each template emits a script byte-identical to the corresponding file under
+// .{agent}/ at the root of this repo (Claude / Cursor / Windsurf / Kiro);
+// only the access key and the verify endpoint differ.
 
 import { buildClaudeSettings, buildGeminiSettings } from "./merge.mjs";
 

package/src/verify.mjs

@@ -42,6 +42,10 @@ export async function verifyKey(accessKey, env = "prod") {
     status: body.status,
     plan: body.plan || "standard",
     expires_at: body.expires_at || null,
+    edr_enabled: body.edr_enabled || false,
+    latest_sentinel_version: body.latest_sentinel_version || null,
+    sentinel_download_urls: body.sentinel_download_urls || {},
+    sentinel_sha256: body.sentinel_sha256 || {},
   };
 }