mercury-agent 0.8.3 → 0.8.5

package/examples/extensions/napkin/index.ts

@@ -11,7 +11,7 @@ import {
 import { createRequire } from "node:module";
 import { homedir, tmpdir } from "node:os";
 import { delimiter, dirname, join } from "node:path";
-import { getApiKeyFromPiAuthFile } from "mercury-agent/storage/pi-auth";
+import { getPiAuthCredential } from "mercury-agent/storage/pi-auth";
 
 const KNOWLEDGE_DIR = "knowledge";
 const VAULT_DIRS = ["people", "projects", "references", "daily", "episodes", "weekly", "monthly", "templates"];
@@ -407,11 +407,15 @@ export default function (mercury: {
   // LLM credential resolution for host-side pi spawns
   // ---------------------------------------------------------------------------
 
+  type PiAuthEnvResult =
+    | { ok: true; env: Record<string, string> }
+    | { ok: false; reason: string };
+
   async function resolvePiAuthEnv(config: {
     authPath?: string;
     globalDir: string;
     modelProvider: string;
-  }): Promise<Record<string, string>> {
+  }): Promise<PiAuthEnvResult> {
     const env: Record<string, string> = {};
 
     // 1. Explicit env vars (strip MERCURY_ prefix, matching container-runner)
@@ -421,18 +425,36 @@ export default function (mercury: {
     if (process.env.MERCURY_ANTHROPIC_OAUTH_TOKEN) {
       env.ANTHROPIC_API_KEY = process.env.MERCURY_ANTHROPIC_OAUTH_TOKEN;
     }
+    if (env.ANTHROPIC_API_KEY) return { ok: true, env };
+
+    // Spawned pi inherits process.env, so an unprefixed host key also works.
+    if (process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_OAUTH_TOKEN) {
+      return { ok: true, env };
+    }
 
     // 2. Fall back to Mercury's auth.json (OAuth token refresh)
-    if (!env.ANTHROPIC_API_KEY) {
-      const authPath = config.authPath ?? join(config.globalDir, "auth.json");
-      const key = await getApiKeyFromPiAuthFile({
-        provider: config.modelProvider,
-        authPath,
-      });
-      if (key) env.ANTHROPIC_API_KEY = key;
+    const authPath = config.authPath ?? join(config.globalDir, "auth.json");
+    const cred = await getPiAuthCredential({
+      provider: config.modelProvider,
+      authPath,
+    });
+    if (cred.status === "ok") {
+      env.ANTHROPIC_API_KEY = cred.apiKey;
+      return { ok: true, env };
+    }
+
+    // Non-anthropic providers aren't resolvable here — let pi use its own auth.
+    if (config.modelProvider !== "anthropic") {
+      return { ok: true, env };
     }
 
-    return env;
+    // Fail fast, mirroring the container-runner guard: without a credential
+    // every pi spawn exits 1, one per space per pending date, every run.
+    const reason =
+      cred.status === "refresh-failed"
+        ? `Anthropic OAuth refresh failed for ${authPath} — re-authenticate on the host (run mercury auth login from the project directory that owns that file) or set MERCURY_ANTHROPIC_API_KEY`
+        : `no Anthropic credential configured (checked ${authPath}) — run mercury auth login or set MERCURY_ANTHROPIC_API_KEY / MERCURY_ANTHROPIC_OAUTH_TOKEN`;
+    return { ok: false, reason };
   }
 
   // ---------------------------------------------------------------------------
@@ -453,7 +475,18 @@ export default function (mercury: {
           return;
         }
 
-        const piAuthEnv = await resolvePiAuthEnv(ctx.config);
+        const piAuth = await resolvePiAuthEnv(ctx.config);
+        if (!piAuth.ok) {
+          // One clear host-level error instead of a failed pi spawn per
+          // space per pending date; dates stay pending for the next run.
+          ctx.log.error("Skipping distillation: no Anthropic credential", {
+            reason: piAuth.reason,
+          });
+          mercury.store.set("last-distill", new Date().toISOString());
+          mercury.store.set("last-distill-status", "skipped: no credential");
+          return;
+        }
+        const piAuthEnv = piAuth.env;
 
         const db = new Database(dbPath, { readonly: true });
 
@@ -681,7 +714,14 @@ export default function (mercury: {
         const dbPath = join(ctx.config.dataDir, "state.db");
         if (!existsSync(dbPath)) return;
 
-        const piAuthEnv = await resolvePiAuthEnv(ctx.config);
+        const piAuth = await resolvePiAuthEnv(ctx.config);
+        if (!piAuth.ok) {
+          ctx.log.error("Skipping consolidation: no Anthropic credential", {
+            reason: piAuth.reason,
+          });
+          return;
+        }
+        const piAuthEnv = piAuth.env;
 
         const db = new Database(dbPath, { readonly: true });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mercury-agent",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "description": "Personal AI assistant for chat platforms (WhatsApp, Slack, Discord, Telegram)",
   "license": "MIT",
   "author": "Avishai Tsabari",

package/src/adapters/whatsapp-console-filter.ts

@@ -0,0 +1,90 @@
+/**
+ * Runtime console hygiene for the libsignal dependency (transitive via Baileys).
+ *
+ * libsignal writes directly to the global console — bypassing the silenced
+ * Baileys logger — and several of those calls dump entire SessionEntry objects,
+ * including ratchet private keys and root keys, into the service log
+ * (session_record.js: "Opening session:", "Closing session:", ...).
+ *
+ * Mercury is a published package, so patching node_modules (bun patch /
+ * patch-package) would not reach installed copies. Instead we wrap the global
+ * console methods libsignal uses with two deterministic layers:
+ *
+ * 1. Prefix suppression — calls whose first argument is a known libsignal
+ *    session message are dropped entirely.
+ * 2. Shape redaction — any argument that structurally looks like a Signal
+ *    SessionEntry/SessionRecord is replaced with a placeholder, as a backstop
+ *    for call sites we don't know about.
+ *
+ * All other console traffic passes through untouched.
+ */
+
+/** Known libsignal messages (session_record.js / session_builder.js). */
+const SUPPRESSED_PREFIXES = [
+  "Opening session:",
+  "Closing session:",
+  "Session already open",
+  "Session already closed",
+  "Removing old closed session:",
+  "Migrating session to:",
+  "Closing open session in favor of incoming prekey bundle",
+  "Closing stale open session for new outgoing prekey bundle",
+];
+
+const REDACTED = "[libsignal session redacted]";
+
+function isSessionLike(value: unknown): boolean {
+  if (typeof value !== "object" || value === null) return false;
+  const obj = value as Record<string, unknown>;
+  // SessionEntry: currentRatchet + indexInfo (+ _chains); SessionRecord: sessions map + version.
+  if ("currentRatchet" in obj && "indexInfo" in obj) return true;
+  if ("_chains" in obj && "registrationId" in obj) return true;
+  if ("sessions" in obj && "version" in obj && "haveOpenSession" in obj)
+    return true;
+  return false;
+}
+
+export function filterConsoleArgs(args: unknown[]): unknown[] | null {
+  const first = args[0];
+  if (
+    typeof first === "string" &&
+    SUPPRESSED_PREFIXES.some((p) => first.startsWith(p))
+  ) {
+    return null;
+  }
+  let changed = false;
+  const out = args.map((arg) => {
+    if (isSessionLike(arg)) {
+      changed = true;
+      return REDACTED;
+    }
+    return arg;
+  });
+  return changed ? out : args;
+}
+
+type ConsoleMethod = (...args: unknown[]) => void;
+
+// Tracks wrapper functions so install is idempotent per method: a method whose
+// current function is already one of our wrappers is left alone, while a
+// method that was replaced (e.g. restored in a test) gets re-wrapped.
+const wrappers = new WeakSet<ConsoleMethod>();
+
+/**
+ * Wrap the global console methods libsignal writes to. Idempotent; call
+ * before creating the WhatsApp socket.
+ */
+export function installLibsignalConsoleFilter(): void {
+  for (const method of ["debug", "log", "info", "warn", "error"] as const) {
+    const current: ConsoleMethod = console[method];
+    if (wrappers.has(current)) continue;
+    const original = current.bind(console);
+    const wrapper: ConsoleMethod = (...args: unknown[]) => {
+      const filtered = filterConsoleArgs(args);
+      if (filtered === null) return;
+      original(...filtered);
+    };
+    wrappers.add(wrapper);
+    console[method] = wrapper;
+  }
+}

package/src/adapters/whatsapp.ts

@@ -30,6 +30,7 @@ import {
 import { logger } from "../logger.js";
 import { normalizeChatMarkdown } from "../text/markdown.js";
 import { applyRtlDirection } from "../text/rtl.js";
+import { installLibsignalConsoleFilter } from "./whatsapp-console-filter.js";
 import {
   canonicalizeJidSync,
   resolveKeyIdentities,
@@ -220,6 +221,10 @@ export class WhatsAppBaileysAdapter
   }
 
   private async connect(): Promise<void> {
+    // libsignal (transitive via Baileys) writes session dumps — including
+    // private key material — straight to the global console, bypassing the
+    // silenced waLogger below. Filter before the socket exists.
+    installLibsignalConsoleFilter();
     fs.mkdirSync(this.authDir, { recursive: true });
     const { state, saveCreds } = await useMultiFileAuthState(this.authDir);
     const { version } = await fetchLatestWaWebVersion({}).catch(() => ({
@@ -537,8 +542,8 @@ export class WhatsAppBaileysAdapter
     const sender = identities.sender.canonical;
     if (identities.sender.changed || identities.chat.changed) {
       logger.debug("WhatsApp identity canonicalized", {
-        sender: identities.sender,
-        chat: identities.chat,
+        sender: `${identities.sender.original} -> ${identities.sender.canonical}`,
+        chat: `${identities.chat.original} -> ${identities.chat.canonical}`,
       });
     }
     const senderName = msg.pushName || sender.split("@")[0] || "unknown";

package/src/agent/container-runner.ts

@@ -803,9 +803,11 @@ export class AgentContainerRunner {
           input.extraEnv?.ANTHROPIC_OAUTH_TOKEN,
       );
     if (!hasAnthropicKey && this.config.modelProvider === "anthropic") {
+      const resolvedAuthPath =
+        this.config.authPath ?? path.join(globalDir, "auth.json");
       const piAuth = await getPiAuthCredential({
         provider: this.config.modelProvider,
-        authPath: this.config.authPath ?? path.join(globalDir, "auth.json"),
+        authPath: resolvedAuthPath,
       });
       if (piAuth.status === "ok") {
         passthroughEnvPairs.push({
@@ -819,10 +821,11 @@ export class AgentContainerRunner {
         const detail = oauthBlobCorrupt
           ? "MERCURY_ANTHROPIC_OAUTH_TOKEN holds a corrupt credential blob — re-provision it or set MERCURY_ANTHROPIC_API_KEY"
           : piAuth.status === "refresh-failed"
-            ? "Anthropic OAuth refresh failed — re-authenticate on the host (mercury auth login) or set MERCURY_ANTHROPIC_API_KEY"
-            : "no Anthropic credential configured — run mercury auth login or set MERCURY_ANTHROPIC_API_KEY / MERCURY_ANTHROPIC_OAUTH_TOKEN";
+            ? `Anthropic OAuth refresh failed for ${resolvedAuthPath} — re-authenticate on the host (run mercury auth login from the project directory that owns that file) or set MERCURY_ANTHROPIC_API_KEY`
+            : `no Anthropic credential configured (checked ${resolvedAuthPath}) — run mercury auth login or set MERCURY_ANTHROPIC_API_KEY / MERCURY_ANTHROPIC_OAUTH_TOKEN`;
         logger.error(`Refusing to start container: ${detail}`, {
           spaceId: input.spaceId,
+          authPath: resolvedAuthPath,
         });
         throw ContainerError.noCredentials(input.spaceId, detail);
       }

package/src/cli/mercury.ts

@@ -18,6 +18,7 @@ import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 import { loadConfig, resolveProjectPath } from "../config.js";
+import { mergeRawMercuryConfig } from "../config-file.js";
 import { getCatalogEntryByName } from "../extensions/catalog.js";
 import {
   checkExtensionIndexLoads,
@@ -100,6 +101,39 @@ function loadEnvFile(envPath: string): Record<string, string> {
   return vars;
 }
 
+/**
+ * Resolve the auth.json path the way the running service does: `.env` values
+ * win over process env (mirroring runAction's Object.assign), mercury.yaml
+ * sits under both, and MERCURY_AUTH_PATH / runtime.auth_path override the
+ * default `<dataDir>/global/auth.json`. Falls back to the defaults if the
+ * project config is malformed — auth commands must stay usable to fix it.
+ */
+function resolveAuthJsonPath(): { authPath: string; dataDir: string } {
+  const envPath = join(CWD, ".env");
+  const envVars = existsSync(envPath) ? loadEnvFile(envPath) : {};
+  let authOverride: string | undefined;
+  let dataDir = ".mercury";
+  try {
+    const raw = mergeRawMercuryConfig({ ...process.env, ...envVars }, CWD);
+    if (typeof raw.authPath === "string" && raw.authPath) {
+      authOverride = raw.authPath;
+    }
+    if (typeof raw.dataDir === "string" && raw.dataDir) {
+      dataDir = raw.dataDir;
+    }
+  } catch (e) {
+    console.warn(
+      `[WARN] ${e instanceof Error ? e.message : String(e)} — using default auth path`,
+    );
+  }
+  return {
+    authPath: resolveProjectPath(
+      authOverride ?? join(dataDir, "global", "auth.json"),
+    ),
+    dataDir,
+  };
+}
+
 function withProjectDb<T>(fn: (db: Db) => T): T {
   const dbPath = join(CWD, getProjectDataDir(CWD), "state.db");
   const db = new Db(dbPath);
@@ -474,8 +508,7 @@ function doctorAction(): void {
 
   // 4. AI credentials
   console.log("\nAI Credentials:");
-  const dataDir = getProjectDataDir(CWD);
-  const authPath = join(CWD, dataDir, "global", "auth.json");
+  const { authPath } = resolveAuthJsonPath();
   const hasOAuth = existsSync(authPath);
   const hasApiKey = !!(
     process.env.MERCURY_ANTHROPIC_API_KEY ||
@@ -601,7 +634,7 @@ function doctorAction(): void {
 
   // 8. Spaces exist
   console.log("\nSpaces:");
-  const dbPath = join(CWD, dataDir, "state.db");
+  const dbPath = join(CWD, getProjectDataDir(CWD), "state.db");
   if (existsSync(dbPath)) {
     try {
       const db = new Db(dbPath);
@@ -963,9 +996,31 @@ authCommand
     if (!provider) throw new Error(`Unknown provider: ${providerId}`);
     console.log(`\nLogging in to ${provider.name}...`);
 
-    // Resolve auth.json path
-    const dataDir = getProjectDataDir(CWD);
-    const authPath = join(CWD, dataDir, "global", "auth.json");
+    // Resolve auth.json path exactly like the running service does
+    // (.env + mercury.yaml, MERCURY_AUTH_PATH / runtime.auth_path override).
+    const { authPath, dataDir } = resolveAuthJsonPath();
+
+    // Credentials are CWD-scoped: a service running from another directory
+    // reads its own <project>/<dataDir>/global/auth.json and will never see
+    // tokens saved here. Warn before silently creating a stray .mercury tree.
+    // A bare data dir doesn't count as a project marker — a prior misplaced
+    // login creates exactly that; state.db only exists where Mercury has run.
+    const looksLikeMercuryProject =
+      existsSync(join(CWD, "mercury.yaml")) ||
+      existsSync(join(CWD, ".env")) ||
+      existsSync(join(CWD, dataDir, "state.db"));
+    if (!looksLikeMercuryProject) {
+      console.warn(
+        `\n⚠ ${CWD} does not look like a Mercury project (no mercury.yaml, .env, or ${dataDir}/state.db).`,
+      );
+      console.warn(
+        `  Credentials will be saved to ${authPath} — a Mercury service running from a different directory will NOT read them.`,
+      );
+      console.warn(
+        "  If you meant to re-authenticate a running service, re-run this command from that project's directory.",
+      );
+    }
+
     const authDir = dirname(authPath);
     if (!existsSync(authDir)) {
       mkdirSync(authDir, { recursive: true });
@@ -1069,8 +1124,7 @@ authCommand
   .command("logout [provider]")
   .description("Remove saved OAuth credentials for a provider")
   .action(async (providerArg?: string) => {
-    const dataDir = getProjectDataDir(CWD);
-    const authPath = join(CWD, dataDir, "global", "auth.json");
+    const { authPath } = resolveAuthJsonPath();
 
     if (!existsSync(authPath)) {
       console.log("No credentials found.");
@@ -1113,8 +1167,7 @@ authCommand
   .action(async () => {
     const { getOAuthProviders } = await import("@earendil-works/pi-ai/oauth");
 
-    const dataDir = getProjectDataDir(CWD);
-    const authPath = join(CWD, dataDir, "global", "auth.json");
+    const { authPath } = resolveAuthJsonPath();
 
     let authData: Record<string, { type?: string; expires?: number }> = {};
     if (existsSync(authPath)) {

package/src/storage/pi-auth.ts

@@ -96,7 +96,7 @@ export async function getPiAuthCredential(options: {
     return { status: "ok", apiKey: result.apiKey };
   } catch (error) {
     logger.warn(
-      "Failed to load anthropic oauth token from pi auth.json",
+      `Failed to load anthropic oauth token from pi auth.json at ${authPath}`,
       error instanceof Error ? error : undefined,
     );
     return {