@agentmemory/fs-watcher 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentmemory/fs-watcher",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Filesystem connector for agentmemory — emits observations on file changes.",
   "type": "module",
   "bin": {

package/watcher.mjs

@@ -1,6 +1,39 @@
-import { watch, promises as fsp, statSync } from "node:fs";
-import { resolve, relative, join, extname, sep, basename } from "node:path";
+import { watch, promises as fsp, readFileSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { resolve, relative, join, extname, sep, basename, dirname } from "node:path";
 import { randomBytes } from "node:crypto";
+import { execFileSync } from "node:child_process";
+
+// Same resolution order as the hooks' resolveProject (git repository basename,
+// then directory basename) so a watched subdirectory scopes to the repository
+// name instead of the subdirectory name.
+function deriveProjectName(dir) {
+  try {
+    const [top, gitDir, commonDir] = execFileSync(
+      "git",
+      ["rev-parse", "--show-toplevel", "--git-dir", "--git-common-dir"],
+      {
+        cwd: dir,
+        stdio: ["ignore", "pipe", "ignore"],
+        encoding: "utf8",
+      },
+    )
+      .trim()
+      .split(/\r?\n/);
+    if (top) return basename(repositoryRoot(dir, top, gitDir, commonDir));
+  } catch {
+    // not a git repo
+  }
+  return basename(dir);
+}
+
+function repositoryRoot(dir, top, gitDir, commonDir) {
+  if (!gitDir || !commonDir) return top;
+  const physical = realpathSync(dir);
+  const common = resolve(physical, commonDir);
+  if (resolve(physical, gitDir) === common || basename(common) !== ".git") return top;
+  return dirname(common);
+}
 
 const TEXT_EXTENSIONS = new Set([
   ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
@@ -28,15 +61,156 @@ const DEFAULT_IGNORE = [
 
 const MAX_PREVIEW_BYTES = 4096;
 const DEBOUNCE_MS = 500;
+const REDACTED = "[REDACTED]";
+const PEM_BEGIN_RE = /-----BEGIN [A-Z ]*PRIVATE KEY-----/;
+const PEM_END_RE = /-----END [A-Z ]*PRIVATE KEY-----/;
+const JWT_RE = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g;
+const JWT_MIN_LEN = 100;
+
+function isDotEnvPath(path) {
+  const name = basename(path).toLowerCase();
+  return name === ".env" || name.startsWith(".env.");
+}
+
+function isSensitiveKey(key) {
+  const normalized = key.replace(/[^a-z0-9]/gi, "").toLowerCase();
+  return [
+    "apikey",
+    "accesstoken",
+    "accesskey",
+    "authorization",
+    "bearer",
+    "clientsecret",
+    "password",
+    "passwd",
+    "privatekey",
+    "pwd",
+    "secret",
+    "token",
+  ].some((needle) => normalized.includes(needle));
+}
+
+function redactJwtTokens(line) {
+  return line.replace(JWT_RE, (match) => (match.length >= JWT_MIN_LEN ? REDACTED : match));
+}
+
+function redactSensitiveLine(line) {
+  if (PEM_BEGIN_RE.test(line) || PEM_END_RE.test(line)) {
+    return line;
+  }
+  const assignment = line.match(
+    /^(\s*(?:export\s+)?["']?([A-Za-z_][A-Za-z0-9_.-]*)["']?\s*([=:])\s*)(.*)$/,
+  );
+  if (assignment && isSensitiveKey(assignment[2])) {
+    const bearer = assignment[3] === ":" ? assignment[4].match(/^(Bearer\s+).+/i) : null;
+    return `${assignment[1]}${bearer ? bearer[1] : ""}${REDACTED}`;
+  }
+  const bearerRedacted = line.replace(
+    /\b(Bearer\s+)[A-Za-z0-9._~+/=-]{8,}\b/gi,
+    `$1${REDACTED}`,
+  );
+  return redactJwtTokens(bearerRedacted);
+}
+
+function redactPemBlocks(preview) {
+  const lines = preview.split("\n");
+  const out = [];
+  let inBlock = false;
+  for (const line of lines) {
+    if (!inBlock) {
+      const beginMatch = line.match(PEM_BEGIN_RE);
+      if (!beginMatch) {
+        out.push(line);
+        continue;
+      }
+      const beginIdx = beginMatch.index;
+      const endMatch = line.match(PEM_END_RE);
+      if (endMatch && endMatch.index > beginIdx) {
+        const before = line.slice(0, beginIdx);
+        const after = line.slice(endMatch.index + endMatch[0].length);
+        out.push(`${before}${beginMatch[0]}${REDACTED}${endMatch[0]}${after}`);
+      } else {
+        out.push(`${line.slice(0, beginIdx)}${beginMatch[0]}`);
+        out.push(REDACTED);
+        inBlock = true;
+      }
+    } else {
+      const endMatch = line.match(PEM_END_RE);
+      if (endMatch) {
+        out.push(`${endMatch[0]}${line.slice(endMatch.index + endMatch[0].length)}`);
+        inBlock = false;
+      }
+    }
+  }
+  return out.join("\n");
+}
+
+function redactSensitivePreview(preview) {
+  return redactPemBlocks(preview).split("\n").map(redactSensitiveLine).join("\n");
+}
+
+function usableSecret(value) {
+  const trimmed = typeof value === "string" ? value.trim() : "";
+  if (!trimmed || (trimmed.startsWith("${") && trimmed.endsWith("}"))) return "";
+  return trimmed;
+}
+
+function readAgentmemoryFile(name) {
+  try {
+    return readFileSync(join(homedir(), ".agentmemory", name), "utf-8");
+  } catch {
+    return "";
+  }
+}
+
+function envFileSecret() {
+  let found = "";
+  for (const line of readAgentmemoryFile(".env").split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) continue;
+    if (trimmed.slice(0, eq).replace(/^export\s+/, "").trim() !== "AGENTMEMORY_SECRET") continue;
+    let value = trimmed.slice(eq + 1).trim();
+    const quote = value[0];
+    const close = quote === '"' || quote === "'" ? value.indexOf(quote, 1) : -1;
+    if (close > 0) value = value.slice(1, close);
+    else if (value.includes(" #")) value = value.slice(0, value.indexOf(" #"));
+    found = usableSecret(value);
+  }
+  return found;
+}
+
+function isLoopbackUrl(url) {
+  try {
+    const host = new URL(url).hostname.replace(/^\[|\]$/g, "").toLowerCase();
+    return host === "localhost" || host === "::1" || /^127(?:\.\d{1,3}){3}$/.test(host);
+  } catch {
+    return false;
+  }
+}
+
+export function resolveSecret(url, explicit) {
+  const configured = usableSecret(explicit);
+  if (configured) return configured;
+  if (!isLoopbackUrl(url)) return "";
+  return envFileSecret() || usableSecret(readAgentmemoryFile("secret"));
+}
 
 export class FilesystemWatcher {
   constructor(config = {}) {
     this.roots = (config.roots || []).map((r) => resolve(r));
     this.baseUrl = (config.baseUrl || "http://localhost:3111").replace(/\/+$/, "");
-    this.secret = config.secret;
+    this.secret = resolveSecret(this.baseUrl, config.secret);
     this.project =
       config.project ||
-      (this.roots[0] ? basename(this.roots[0]) : "filesystem-watcher");
+      (this.roots[0] ? deriveProjectName(this.roots[0]) : "filesystem-watcher");
+    // Per-root scope: a multi-root watcher must stamp each event with the
+    // project of the root that produced it, not the first root's project.
+    // An explicit config.project overrides for every root.
+    this.projectByRoot = new Map(
+      this.roots.map((r) => [r, config.project || deriveProjectName(r)]),
+    );
     this.sessionId =
       config.sessionId ||
       `fs-watcher-${Date.now().toString(36)}-${randomBytes(3).toString("hex")}`;
@@ -54,7 +228,7 @@ export class FilesystemWatcher {
   isTextFile(path) {
     if (this.allowBinary) return true;
     const ext = extname(path).toLowerCase();
-    return TEXT_EXTENSIONS.has(ext);
+    return TEXT_EXTENSIONS.has(ext) || isDotEnvPath(path);
   }
 
   async readPreview(path) {
@@ -121,12 +295,13 @@ export class FilesystemWatcher {
     let preview = null;
     if (exists && this.isTextFile(absPath)) {
       preview = await this.readPreview(absPath);
+      if (preview !== null) preview = redactSensitivePreview(preview);
     }
     const truncated = exists && size > MAX_PREVIEW_BYTES;
     const payload = {
       hookType: "post_tool_use",
       sessionId: this.sessionId,
-      project: this.project,
+      project: this.projectByRoot.get(rootDir) ?? this.project,
       cwd: rootDir,
       timestamp: new Date().toISOString(),
       data: {
@@ -160,6 +335,18 @@ export class FilesystemWatcher {
     const failures = [];
     for (const root of this.roots) {
       try {
+        // Validate the root before handing it to fs.watch: on Linux with
+        // Node 24+, fs.watch on a nonexistent path no longer throws
+        // synchronously, so a missing root would otherwise count as
+        // "attached" and be watched-in-name-only. An explicit stat keeps
+        // the failure deterministic across Node versions and platforms.
+        const st = statSync(root, { throwIfNoEntry: false });
+        if (!st) {
+          throw new Error("no such directory");
+        }
+        if (!st.isDirectory()) {
+          throw new Error("not a directory");
+        }
         const handle = watch(
           root,
           { recursive: true, persistent: true },
@@ -219,7 +406,13 @@ export function configFromEnv(env = process.env) {
     roots,
     baseUrl: env.AGENTMEMORY_URL,
     secret: env.AGENTMEMORY_SECRET,
-    project: env.AGENTMEMORY_PROJECT || null,
+    // AGENTMEMORY_PROJECT_NAME is the canonical override (matches the hooks);
+    // AGENTMEMORY_PROJECT stays as a deprecated alias for existing setups.
+    // Trimmed, with whitespace-only treated as unset, same as resolveProject.
+    project:
+      (env.AGENTMEMORY_PROJECT_NAME || "").trim() ||
+      (env.AGENTMEMORY_PROJECT || "").trim() ||
+      null,
     sessionId: env.AGENTMEMORY_SESSION_ID || null,
     ignorePatterns: extraIgnore,
     allowBinary: env.AGENTMEMORY_FS_WATCH_ALLOW_BINARY === "1",