@coworker-jp/aidr 0.1.9 → 0.1.11

package/package.json

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

package/src/binary-fetcher.mjs

@@ -14,6 +14,7 @@ export function detectPlatform() {
   if (os === "linux" && arch === "x64") return "linux-x86_64";
   if (os === "linux" && arch === "arm64") return "linux-aarch64";
   if (os === "darwin" && arch === "arm64") return "darwin-aarch64";
+  if (os === "win32" && arch === "x64") return "windows-x86_64";
   if (os === "darwin" && arch === "x64") {
     throw new Error("Intel Mac (darwin-x86_64) is not supported. Apple Silicon only.");
   }
@@ -162,28 +163,50 @@ export async function fetchOpengrep(destPath) {
  * otherwise falls back to the licensed download endpoint.
  * Returns { path, platform, sha256, verified }.
  */
-export async function fetchSentinel(destPath, { accessKey, presignedUrl, env = "prod" } = {}) {
+export async function fetchSentinel(
+  destPath,
+  { accessKey, presignedUrl, dllPresignedUrl, env = "prod" } = {},
+) {
   const platform = detectPlatform();
 
   let binUrl;
+  let binAuthKey = accessKey;
   if (presignedUrl) {
     // Use presigned URL from verify response (no auth header needed)
     binUrl = presignedUrl;
-    accessKey = undefined;
+    binAuthKey = 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 buf = await fetchBuffer(binUrl, binAuthKey);
   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.chmod(tmp, 0o755); // no-op on Windows; harmless
   await fsp.rename(tmp, destPath);
   await clearQuarantine(destPath);
 
+  // Windows also needs the sibling WinDivert.dll — a PE import the loader
+  // resolves before the exe's own code runs, so it can't be embedded (unlike
+  // WinDivert64.sys, which is embedded and self-extracts at first run).
+  if (platform === "windows-x86_64") {
+    const dllPath = path.join(path.dirname(destPath), "WinDivert.dll");
+    let dllUrl = dllPresignedUrl;
+    let dllAuthKey;
+    if (dllUrl) {
+      dllAuthKey = undefined;
+    } else {
+      const base = downloadBase(env);
+      dllUrl = `${base}/sentinel/${platform}/WinDivert.dll`;
+      dllAuthKey = accessKey;
+    }
+    const dllBuf = await fetchBuffer(dllUrl, dllAuthKey);
+    await fsp.writeFile(dllPath, dllBuf);
+  }
+
   return { path: destPath, platform, sha256, verified: false };
 }

package/src/cli.mjs

@@ -154,6 +154,15 @@ async function cmdInstall(opts) {
     opts.scheduled = true;
   }
 
+  // On Windows there is no ai-scanner binary and no cron/systemd/launchd, so
+  // the scheduled endpoint-info scan cannot run — the standalone install is
+  // coworker-sentinel-only there (`--with-sentinel` installs the daemon below).
+  // Force scheduled off so it doesn't abort the install before sentinel.
+  if (process.platform === "win32" && opts.scheduled) {
+    console.error("Note: scheduled scanning is not available on Windows; installing coworker-sentinel only.");
+    opts.scheduled = false;
+  }
+
   // --scheduled installs a system-wide cron / systemd / launchd entry that
   // runs `ai-scanner scan endpoint-info` periodically as root, against an
   // agent-independent binary at /opt/coworker/aidr/bin/ai-scanner. Auto-add
@@ -327,11 +336,15 @@ async function cmdInstall(opts) {
     try {
       const platform = (await import("./binary-fetcher.mjs")).detectPlatform();
       const presignedUrl = verifyInfo?.sentinel_download_urls?.[platform] || undefined;
+      // Windows additionally needs the sibling WinDivert.dll presigned URL.
+      const dllPresignedUrl =
+        verifyInfo?.sentinel_download_urls?.[`${platform}-windivert-dll`] || undefined;
       await installSentinel({
         accessKey: opts.key,
         dryRun: opts.dryRun,
         skipBinary: opts.skipBinary,
         presignedUrl,
+        dllPresignedUrl,
         env: opts.env || DEFAULT_ENV,
         noActivate: process.env.AI_SCANNER_NO_SCHEDULED_ACTIVATE === "1",
       });

package/src/scheduled.mjs

@@ -15,11 +15,22 @@ const execFileP = promisify(execFile);
 // without ever touching real /etc or /opt. Production should never set this.
 const ROOT_PREFIX = process.env.AIDR_SCHEDULED_ROOT || "";
 
-export const SYSTEM_BIN_DIR     = ROOT_PREFIX + "/opt/coworker/aidr/bin";
+// Windows uses %ProgramFiles% / %ProgramData% instead of the FHS paths. Only
+// the constants coworker-sentinel needs are Windows-aware; the POSIX values
+// (and the launchd/cron/logrotate constants below) are unchanged off-Windows.
+const IS_WIN = process.platform === "win32";
+const WIN_PROGRAMDATA = process.env.ProgramData || "C:\\ProgramData";
+const WIN_PROGRAMFILES = process.env.ProgramFiles || "C:\\Program Files";
+
+export const SYSTEM_BIN_DIR     = IS_WIN
+  ? path.join(WIN_PROGRAMFILES, "coworker", "aidr", "bin")
+  : ROOT_PREFIX + "/opt/coworker/aidr/bin";
 export const SYSTEM_BIN         = path.join(SYSTEM_BIN_DIR, "ai-scanner");
 export const SYSTEM_OPENGREP    = path.join(SYSTEM_BIN_DIR, "opengrep");
 export const SYSTEM_USR_LOCAL_BIN = ROOT_PREFIX + "/usr/local/bin/ai-scanner";
-const SYSTEM_ENV_DIR            = ROOT_PREFIX + "/etc/aidr";
+const SYSTEM_ENV_DIR            = IS_WIN
+  ? path.join(WIN_PROGRAMDATA, "coworker")
+  : ROOT_PREFIX + "/etc/aidr";
 export const SYSTEM_ENV_FILE    = path.join(SYSTEM_ENV_DIR, "aidr.env");
 
 // macOS launchd (LaunchDaemons run as root, available pre-login)
@@ -35,7 +46,9 @@ export const CRON_FILE        = ROOT_PREFIX + "/etc/cron.d/aidr-scheduled";
 // 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 SYSTEM_LOG_DIR     = IS_WIN
+  ? path.join(WIN_PROGRAMDATA, "coworker", "logs")
+  : 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");
 export const LOGROTATE_FILE     = ROOT_PREFIX + "/etc/logrotate.d/coworker";
@@ -75,6 +88,9 @@ export async function ensureSystemLogDir(logFile, { dryRun = false } = {}) {
  * without logrotate should configure their own rotation.
  */
 export async function writeLogrotateConfig({ dryRun = false } = {}) {
+  // logrotate is a Unix tool; Windows has no equivalent here (the service can
+  // size-rotate its own audit log). No-op on Windows.
+  if (process.platform === "win32") return;
   const body = `# Generated by aidr install. Covers both aidr-scheduled (weekly) and
 # coworker-sentinel (daily, more chatty under load).
 /var/log/coworker/scheduled.log {

package/src/sentinel.mjs

@@ -29,12 +29,24 @@ 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_BIN = path.join(
+  SYSTEM_BIN_DIR,
+  process.platform === "win32" ? "coworker-sentinel.exe" : "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_WIN_SERVICE = "CoworkerSentinel";
 
 function isRoot() {
   if (process.env.AI_SCANNER_FAKE_ROOT === "1") return true;
+  if (process.platform === "win32") {
+    // No uid on Windows; `net session` succeeds only from an elevated shell.
+    try {
+      return spawnSync("net", ["session"], { stdio: "ignore" }).status === 0;
+    } catch {
+      return false;
+    }
+  }
   return Boolean(process.getuid && process.getuid() === 0);
 }
 
@@ -43,6 +55,13 @@ async function exists(p) {
 }
 
 export async function isSentinelInstalled() {
+  if (process.platform === "win32") {
+    try {
+      return spawnSync("sc", ["query", SENTINEL_WIN_SERVICE], { stdio: "ignore" }).status === 0;
+    } catch {
+      return false;
+    }
+  }
   return (
     (await exists(SENTINEL_PLIST)) ||
     (await exists(SENTINEL_SERVICE))
@@ -111,12 +130,15 @@ WantedBy=multi-user.target
  *   env          — "dev" | "prod"
  */
 export async function installSentinel(opts = {}) {
-  const { accessKey, dryRun = false, skipBinary = false, noActivate = false, presignedUrl, env = "prod" } = opts;
+  const { accessKey, dryRun = false, skipBinary = false, noActivate = false, presignedUrl, dllPresignedUrl, 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"
+      process.platform === "win32"
+        ? "installSentinel requires an elevated (Administrator) shell.\n" +
+          "Re-run from an Administrator PowerShell/cmd: npx @coworker-jp/aidr install --key <key> --with-sentinel"
+        : "installSentinel requires root privileges.\n" +
+          "Re-run with: sudo -E npx @coworker-jp/aidr install --key <key> --with-sentinel",
     );
   }
 
@@ -127,7 +149,7 @@ export async function installSentinel(opts = {}) {
   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 });
+    await fetchSentinel(SENTINEL_BIN, { accessKey, presignedUrl, dllPresignedUrl, env });
   } else if (skipBinary) {
     console.error(`[sentinel] Skipping binary download (--skip-binary)`);
   } else {
@@ -168,8 +190,10 @@ export async function installSentinel(opts = {}) {
     }
   }
 
-  // 4. Write service/plist
-  if (process.platform === "darwin") {
+  // 4. Write service/plist (or register the Windows service)
+  if (process.platform === "win32") {
+    await _installWindows(dryRun, noActivate);
+  } else if (process.platform === "darwin") {
     await _installMacos(dryRun, noActivate);
   } else {
     await _installLinux(dryRun, noActivate);
@@ -178,6 +202,44 @@ export async function installSentinel(opts = {}) {
   console.error("[sentinel] Installation complete.");
 }
 
+async function _installWindows(dryRun, noActivate) {
+  if (dryRun) {
+    console.error(`[sentinel] DRY-RUN: would run \`${SENTINEL_BIN} install-ca\` + install-service`);
+    return;
+  }
+  // The service (LocalSystem) reads AI_SCANNER_ACCESS_KEY etc. from
+  // %ProgramData%\coworker\aidr.env, written by installSentinel step 3.
+  // install-ca adds the DLP root to the OS trust store; install-service
+  // registers the auto-start service and starts it immediately.
+  await execFileP(SENTINEL_BIN, ["install-ca"]);
+  console.error("[sentinel] Root CA installed into the Windows trust store");
+  if (!noActivate && process.env.AI_SCANNER_NO_SCHEDULED_ACTIVATE !== "1") {
+    await execFileP(SENTINEL_BIN, ["install-service"]);
+    console.error(`[sentinel] Service registered and started (${SENTINEL_WIN_SERVICE})`);
+  } else {
+    console.error("[sentinel] --no-activate: skipping service registration");
+  }
+}
+
+async function _uninstallWindows(dryRun) {
+  if (dryRun) {
+    console.error("[sentinel] DRY-RUN: would run uninstall-service + uninstall-ca");
+    return;
+  }
+  // Order mirrors the CLI dispatch: stop/remove the service (so the exe isn't
+  // in use), then drop the MITM root CA so no dangling trust anchor remains.
+  try {
+    await execFileP(SENTINEL_BIN, ["uninstall-service"]);
+  } catch (e) {
+    console.warn("[sentinel] uninstall-service:", e.message);
+  }
+  try {
+    await execFileP(SENTINEL_BIN, ["uninstall-ca"]);
+  } catch (e) {
+    console.warn("[sentinel] uninstall-ca:", e.message);
+  }
+}
+
 async function _installMacos(dryRun, noActivate) {
   const plistContent = buildLaunchdPlist(SYSTEM_ENV_FILE);
   if (!dryRun) {
@@ -230,7 +292,9 @@ export async function uninstallSentinel({ dryRun = false } = {}) {
 
   console.error("[sentinel] Uninstalling coworker-sentinel…");
 
-  if (process.platform === "darwin") {
+  if (process.platform === "win32") {
+    await _uninstallWindows(dryRun);
+  } else if (process.platform === "darwin") {
     if (await exists(SENTINEL_PLIST)) {
       if (!dryRun) {
         // Modern launchctl API; mirrors scheduled.mjs's uninstallScheduled.
@@ -263,6 +327,19 @@ export async function uninstallSentinel({ dryRun = false } = {}) {
     }
   }
 
+  // Windows ships a sibling WinDivert.dll next to the exe — remove it too.
+  if (process.platform === "win32") {
+    const dll = path.join(path.dirname(SENTINEL_BIN), "WinDivert.dll");
+    if (await exists(dll)) {
+      if (!dryRun) {
+        await fs.unlink(dll);
+        console.error(`[sentinel] Removed: ${dll}`);
+      } else {
+        console.error(`[sentinel] DRY-RUN: would remove ${dll}`);
+      }
+    }
+  }
+
   // Drop the sentinel log file. removeSystemLog also rmdirs SYSTEM_LOG_DIR
   // and deletes /etc/logrotate.d/coworker if scheduled.log is also gone
   // (i.e. the other daemon is uninstalled).