@coworker-jp/aidr 0.0.3 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coworker-jp/aidr",
-  "version": "0.0.3",
+  "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

@@ -89,16 +89,42 @@ async function cmdInstall(opts) {
   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);
@@ -246,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)");
@@ -298,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);
@@ -517,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.3");
+    .version("0.0.4");
 
   program
     .command("install")
@@ -536,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/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 || {},
   };
 }