@mnemom/mnemom 0.17.4-next.7 → 0.17.4-next.8

package/dist/commands/agent-doctor.js

@@ -13,7 +13,8 @@
  */
 import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
-import { anthropicKeySource, checkRcCapability, resolveCliBin } from "./agent.js";
+import { anthropicKeySource, checkRcCapability, defaultConsoleKeyDeps, resolveCliBin, } from "./agent.js";
+import { readConsoleKey } from "../lib/console-key.js";
 import { resolveAgentAuth } from "../lib/subscription-login.js";
 import { isProdGateway, resolveAnthropicDoor, resolveGatewayHost, singleCellError, } from "../lib/agent.js";
 import { getApiUrl, getGatewayUrl } from "../lib/config.js";
@@ -52,11 +53,17 @@ export async function agentDoctorCommand(options = {}) {
         auth = resolveAgentAuth(undefined, env);
     }
     catch (err) {
-        add("miss", `auth: ${err instanceof Error ? err.message : String(err)}`, "`mnemom agent config set auth api-key` (or subscription)");
+        add("miss", `auth: ${err instanceof Error ? err.message : String(err)}`, "`mnemom agent config set auth api-key` (or subscription, console)");
     }
     if (auth === "subscription") {
         add("ok", "auth: subscription — Claude Code uses your claude.ai login (Team/Enterprise plans only); no Anthropic key needed");
     }
+    else if (auth === "console") {
+        if (readConsoleKey(defaultConsoleKeyDeps(env)))
+            add("ok", "auth: console — using the API key your Claude Code Anthropic Console login created");
+        else
+            add("miss", "auth: console — Claude Code has no Anthropic Console login on this machine", 'run `claude`, then /login → "Anthropic Console account" — or `mnemom agent config set auth api-key`');
+    }
     else {
         const keySrc = anthropicKeySource(env);
         if (keySrc === "env")

package/dist/commands/agent.d.ts

@@ -28,6 +28,7 @@
 import { type MnemomKeyDeps } from "../lib/subscription-login.js";
 import { type SessionRecord } from "../lib/agent-ledger.js";
 import { type ExperimentalId } from "../lib/experimental.js";
+import { type ConsoleKeyDeps } from "../lib/console-key.js";
 import { type ContextProfile, type LaunchShape, type SealedContractEnvelope } from "../lib/agent.js";
 export interface AgentOptions {
     goal?: string;
@@ -191,6 +192,8 @@ export declare function recordSessionLaunch(ctx: {
 }): Promise<void>;
 /** The real I/O behind a subscription launch's Mnemom key (lib/subscription-login.ts). */
 export declare function defaultMnemomKeyDeps(storePath?: string): MnemomKeyDeps;
+/** The real machine behind lib/console-key.ts: the macOS keychain via `security`, no shell. */
+export declare function defaultConsoleKeyDeps(env: NodeJS.ProcessEnv): ConsoleKeyDeps;
 /**
  * Resolve the Anthropic key with NO 1Password dependency (built for external
  * customer adoption), in order:

package/dist/commands/agent.js

@@ -28,7 +28,7 @@
 import { spawn, spawnSync } from "node:child_process";
 import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync, renameSync, } from "node:fs";
 import { randomUUID } from "node:crypto";
-import { tmpdir, homedir, hostname } from "node:os";
+import { tmpdir, homedir, hostname, userInfo } from "node:os";
 import { basename, join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { getApiUrl, getGatewayUrl, MNEMOM_DIR } from "../lib/config.js";
@@ -41,6 +41,7 @@ import { experimentalNotice } from "../lib/experimental.js";
 import { fmt } from "../lib/format.js";
 import { askInput, askSelect, askYesNo, isInteractive } from "../lib/prompt.js";
 import { authConfigured, chooseAuth, detectClaudeLogin, readClaudeLoginState, } from "../lib/login-detect.js";
+import { requireConsoleKey, readConsoleKey } from "../lib/console-key.js";
 import { goalAlignmentLine, resolveSessionSetup } from "./agent-session.js";
 import { AgentIdentityMismatchError, defaultAgentSlug, ensureGovernedAgent, ensureSessionAndBalance, isQuietPreambleExit, resolveDefaultSlug, resolvePreflightedAccount, } from "./agent-setup.js";
 import { assembleContract, buildGoalModeHeader, buildCustomHeaders, buildHandoffMcpConfigJson, buildSessionConfig, buildSessionConfigB64, applyGatewayHintHeaders, resolveCompactionIntercept, resolveContextHandoff, resolveContextProfile, resolveHandoffGatewayHost, HANDOFF_RC_KEY_ENV_NAME, isProdGateway, launchPreferenceExplicit, launchPreflighted, remoteControlAllowed, applyToolSearchDefault, DISABLE_1M_ENV, readCcSettings, resolveWindowModel, resolveAnthropicDoor, resolveLaunchModel, resolveConversationId, resolveGatewayHost, singleCellError, resolveLaunchShape, resolveRemoteControlShape, passthroughName, sanitizeAgentName, sessionDisplayName, SESSION_NAME_ENV, SESSION_CONFIG_HEADER, } from "../lib/agent.js";
@@ -87,8 +88,10 @@ export async function agentCommand(scenarioArg, options = {}) {
     // Nothing configured it yet: detect Claude Code's own login and, when there is a real
     // choice, ask once and save the answer (lib/login-detect.ts). Never on --dry-run.
     if (!options.dryRun && !authConfigured(options.auth, env)) {
+        const loginState = readClaudeLoginState(env, homedir(), (path) => readFileSync(path, "utf8"));
         auth = await chooseAuth({
-            login: detectClaudeLogin(readClaudeLoginState(env, homedir(), (path) => readFileSync(path, "utf8"))),
+            login: detectClaudeLogin(loginState),
+            consoleKeyAvailable: () => readConsoleKey(defaultConsoleKeyDeps(env)) !== undefined,
             interactive: isInteractive(),
             select: askSelect,
             persist: (choice) => {
@@ -214,6 +217,9 @@ export async function agentCommand(scenarioArg, options = {}) {
         if (auth === "subscription") {
             say("mnemom agent: auth = subscription — Claude Code would use your claude.ai login (Team/Enterprise plans only) with a Mnemom API key; no Anthropic key.");
         }
+        if (auth === "console") {
+            say("mnemom agent: auth = console — the launch would use the API key your Claude Code Anthropic Console login created.");
+        }
         if (expNotice)
             say(expNotice);
         if (previewShape === "remote-control") {
@@ -235,9 +241,12 @@ export async function agentCommand(scenarioArg, options = {}) {
     }
     // ── resolve the Anthropic key (zero 1Password; never logged) ──
     // Not on a subscription launch: Claude Code then sends its own claude.ai login instead.
-    const anthropicKey = auth === "api-key"
-        ? await resolveAnthropicKey(env, { allowPrompt: true, keySource: options.keySource })
-        : undefined;
+    // A Console launch uses the key Claude Code's Console login created, then runs as api-key.
+    const anthropicKey = auth === "subscription"
+        ? undefined
+        : auth === "console"
+            ? requireConsoleKey(defaultConsoleKeyDeps(env))
+            : await resolveAnthropicKey(env, { allowPrompt: true, keySource: options.keySource });
     // ── account + µ-balance gate (no free tier) ─────────────────────────────────
     // mnemom agent runs governed and on µ, so before we seal a contract or launch we
     // (1) ensure a Mnemom session — offering the try-me-style sign-in / sign-up when
@@ -675,6 +684,23 @@ export function defaultMnemomKeyDeps(storePath = CODE_STORE) {
         say,
     };
 }
+/** The real machine behind lib/console-key.ts: the macOS keychain via `security`, no shell. */
+export function defaultConsoleKeyDeps(env) {
+    return {
+        platform: process.platform,
+        env,
+        username: () => userInfo().username,
+        readKeychain: (service, account) => {
+            const r = spawnSync("security", ["find-generic-password", "-a", account, "-w", "-s", service], {
+                encoding: "utf8",
+                timeout: 5_000,
+            });
+            return r.status === 0 ? r.stdout : undefined;
+        },
+        claudeJson: readClaudeLoginState(env, homedir(), (path) => readFileSync(path, "utf8"))
+            .claudeJson,
+    };
+}
 /**
  * Resolve the Anthropic key with NO 1Password dependency (built for external
  * customer adoption), in order:

package/dist/index.js

@@ -143,7 +143,7 @@ const agentCmd = program
     .option("--gateway <url>", "Gateway host override — must be the same cell as the rest of the CLI (default: that cell's gateway; or MNEMOM_AGENT_GATEWAY)")
     .option("--remote-control", "Interactive Remote Control session in THIS terminal (behind a local proxy)")
     .option("--server", "Headless `claude remote-control` dispatcher (behind a local proxy)")
-    .option("--auth <mode>", "How Claude Code authenticates: api-key (default) | subscription (your Claude Team/Enterprise login)")
+    .option("--auth <mode>", "How Claude Code authenticates: api-key (default) | subscription (your Claude Team/Enterprise login) | console (the API key your Claude Code Anthropic Console login created)")
     .option("--model <alias|id>", "Model to launch (CLI alias or concrete id)")
     .addOption(new Option("--effort <level>", "Reasoning effort").choices([
     "low",

package/dist/lib/console-key.d.ts

@@ -0,0 +1,40 @@
+/**
+ * `mnemom agent` with an Anthropic Console login (`auth = console`).
+ *
+ * Claude Code's `/login` → "Anthropic Console account" uses OAuth only to create a real
+ * Anthropic API key, which Claude Code stores and then sends as `x-api-key` ("/login
+ * managed key"). This module reads that key from where Claude Code keeps it, so the launch
+ * runs exactly like `auth = api-key` — same headers, same birth and claim, same identity —
+ * with no key for the user to copy. The key is read per launch and never stored by us.
+ *
+ * Where Claude Code keeps it (Claude Code 2.1.285, confirmed against the binary and a live
+ * probe on 2026-10-02):
+ *   - macOS: the login keychain, service `Claude Code`, account $USER. When
+ *     CLAUDE_CONFIG_DIR is set the service gains `-<first 8 hex of sha256(the raw
+ *     CLAUDE_CONFIG_DIR value, NFC)>`; CLAUDE_SECURESTORAGE_CONFIG_DIR, when set, replaces
+ *     that value (empty = no suffix).
+ *   - everywhere (and the macOS fallback): `primaryApiKey` in Claude Code's .claude.json.
+ *
+ * A `claude auth login --console` *profile* (keyless OAuth, ~/.config/anthropic) creates no
+ * such key, so it is not read here.
+ *
+ * Pure apart from the injected deps, so every arm is unit-tested.
+ */
+export interface ConsoleKeyDeps {
+    platform: NodeJS.Platform;
+    env: Record<string, string | undefined>;
+    /** os.userInfo().username, for when $USER is unset. */
+    username(): string;
+    /** The keychain password for (service, account), or undefined when absent. */
+    readKeychain(service: string, account: string): string | undefined;
+    /** Parsed .claude.json (see readClaudeLoginState), or undefined. */
+    claudeJson: unknown;
+}
+/** The keychain service name Claude Code stores the managed key under. */
+export declare function claudeKeychainService(env: Record<string, string | undefined>): string;
+/** The keychain account Claude Code uses: $USER, else the OS username, else a fixed name. */
+export declare function claudeKeychainAccount(env: Record<string, string | undefined>, username: () => string): string;
+/** Claude Code's Console-login API key on this machine, or undefined. Never throws. */
+export declare function readConsoleKey(deps: ConsoleKeyDeps): string | undefined;
+/** The key for an `auth = console` launch; throws with what to do when there is none. */
+export declare function requireConsoleKey(deps: ConsoleKeyDeps): string;

package/dist/lib/console-key.js

@@ -0,0 +1,77 @@
+/**
+ * `mnemom agent` with an Anthropic Console login (`auth = console`).
+ *
+ * Claude Code's `/login` → "Anthropic Console account" uses OAuth only to create a real
+ * Anthropic API key, which Claude Code stores and then sends as `x-api-key` ("/login
+ * managed key"). This module reads that key from where Claude Code keeps it, so the launch
+ * runs exactly like `auth = api-key` — same headers, same birth and claim, same identity —
+ * with no key for the user to copy. The key is read per launch and never stored by us.
+ *
+ * Where Claude Code keeps it (Claude Code 2.1.285, confirmed against the binary and a live
+ * probe on 2026-10-02):
+ *   - macOS: the login keychain, service `Claude Code`, account $USER. When
+ *     CLAUDE_CONFIG_DIR is set the service gains `-<first 8 hex of sha256(the raw
+ *     CLAUDE_CONFIG_DIR value, NFC)>`; CLAUDE_SECURESTORAGE_CONFIG_DIR, when set, replaces
+ *     that value (empty = no suffix).
+ *   - everywhere (and the macOS fallback): `primaryApiKey` in Claude Code's .claude.json.
+ *
+ * A `claude auth login --console` *profile* (keyless OAuth, ~/.config/anthropic) creates no
+ * such key, so it is not read here.
+ *
+ * Pure apart from the injected deps, so every arm is unit-tested.
+ */
+import { createHash } from "node:crypto";
+const ACCOUNT_RE = /^[a-zA-Z0-9._-]+$/;
+/** The keychain service name Claude Code stores the managed key under. */
+export function claudeKeychainService(env) {
+    const secure = env.CLAUDE_SECURESTORAGE_CONFIG_DIR;
+    const dir = secure !== undefined ? secure : (env.CLAUDE_CONFIG_DIR ?? "");
+    if (!dir)
+        return "Claude Code";
+    const hash = createHash("sha256").update(dir.normalize("NFC")).digest("hex").slice(0, 8);
+    return `Claude Code-${hash}`;
+}
+/** The keychain account Claude Code uses: $USER, else the OS username, else a fixed name. */
+export function claudeKeychainAccount(env, username) {
+    let name;
+    try {
+        name = env.USER || username();
+    }
+    catch {
+        name = "";
+    }
+    return ACCOUNT_RE.test(name) ? name : "claude-code-user";
+}
+/** The key is spliced into a newline-joined header block, so CR/LF must never survive. */
+function clean(raw) {
+    const v = (raw ?? "").replace(/[\r\n]+/g, "").trim();
+    return v || undefined;
+}
+/** Claude Code's Console-login API key on this machine, or undefined. Never throws. */
+export function readConsoleKey(deps) {
+    if (deps.platform === "darwin") {
+        let fromKeychain;
+        try {
+            fromKeychain = clean(deps.readKeychain(claudeKeychainService(deps.env), claudeKeychainAccount(deps.env, deps.username)));
+        }
+        catch {
+            fromKeychain = undefined;
+        }
+        if (fromKeychain)
+            return fromKeychain;
+    }
+    const json = deps.claudeJson;
+    const stored = json && typeof json === "object"
+        ? json.primaryApiKey
+        : undefined;
+    return typeof stored === "string" ? clean(stored) : undefined;
+}
+/** The key for an `auth = console` launch; throws with what to do when there is none. */
+export function requireConsoleKey(deps) {
+    const key = readConsoleKey(deps);
+    if (key)
+        return key;
+    throw new Error("mnemom agent: auth = console, but Claude Code has no Anthropic Console login on this machine.\n" +
+        '  Sign in: run `claude`, then /login → "Anthropic Console account".\n' +
+        "  Or use a key instead: `mnemom agent config set auth api-key`.");
+}

package/dist/lib/launcher-config.js

@@ -135,7 +135,7 @@ export const CONFIG_KEYS = [
     },
     {
         key: "auth",
-        describe: `How Claude Code authenticates (${AGENT_AUTHS.join("|")}); subscription = your Claude Team/Enterprise login`,
+        describe: `How Claude Code authenticates (${AGENT_AUTHS.join("|")}); subscription = your Claude Team/Enterprise login, console = your Claude Code Anthropic Console login's key`,
         get: (c) => c.auth,
         set: (c, v) => {
             c.auth = coerceAgentAuth(v);

package/dist/lib/login-detect.d.ts

@@ -6,7 +6,9 @@
  * Four ways Claude Code can be signed in, and what the gateway does with each today:
  *   - Claude subscription, Team or Enterprise → `auth = subscription` (supported).
  *   - Claude subscription, Pro / Max (individual) → not supported (Team/Enterprise only).
- *   - Anthropic Console login → not supported yet.
+ *   - Anthropic Console login (`/login` → Console account) → `auth = console` (supported): the
+ *     API key Claude Code created is read from its keychain (lib/console-key.ts). A
+ *     `claude auth login --console` profile creates no key → not supported yet.
  *   - Third-party provider (Bedrock / Vertex / Foundry) → not supported yet (no gateway door).
  * An Anthropic API key always works (`auth = api-key`, the default).
  *
@@ -16,7 +18,7 @@
  *
  * Pure apart from the injected deps, so every arm is unit-tested.
  */
-import type { AgentAuth } from "./subscription-login.js";
+import { type AgentAuth } from "./subscription-login.js";
 export type ThirdPartyProvider = "bedrock" | "vertex" | "foundry";
 export type ClaudeLogin = {
     kind: "subscription";
@@ -46,10 +48,13 @@ export type UnsupportedLogin = Extract<ClaudeLogin, {
 /** Why a detected login can't be used through the gateway. */
 export declare function unsupportedReason(login: UnsupportedLogin): string;
 export declare const MENU_SUBSCRIPTION = "Claude subscription \u2014 Team or Enterprise (your claude.ai login)";
+export declare const MENU_CONSOLE = "Anthropic Console \u2014 the API key your Claude Code /login created (API billing)";
 export declare const MENU_API_KEY = "Anthropic API key";
 export interface ChooseAuthDeps {
     login: ClaudeLogin;
     interactive: boolean;
+    /** Whether Claude Code's Console-login key is readable (lib/console-key.ts); asked only for a Console login. */
+    consoleKeyAvailable(): boolean;
     select(question: string, options: string[]): Promise<string | null>;
     persist(auth: AgentAuth): void;
     say(line: string): void;
@@ -58,8 +63,9 @@ export interface ChooseAuthDeps {
  * Pick `auth` when nothing configured it (no --auth, MNEMOM_AGENT_AUTH or launcher.toml).
  *   - No Claude login detected → api-key, silently, nothing saved (today's behaviour).
  *   - A login we can't use → api-key, say why once, save it so the note isn't repeated.
- *   - Team/Enterprise and non-interactive → api-key, nothing saved (never switch a script's
- *     auth without asking); interactive → a two-option menu (subscription or API key), answer saved.
+ *   - Team/Enterprise, or a Console login whose key is readable, and non-interactive →
+ *     api-key, nothing saved (never switch a script's auth without asking); interactive → a
+ *     two-option menu (that login or an API key), answer saved.
  */
 export declare function chooseAuth(deps: ChooseAuthDeps): Promise<AgentAuth>;
 /** True when `auth` is already decided: `--auth`, or MNEMOM_AGENT_AUTH (launcher.toml folds in). */

package/dist/lib/login-detect.js

@@ -6,7 +6,9 @@
  * Four ways Claude Code can be signed in, and what the gateway does with each today:
  *   - Claude subscription, Team or Enterprise → `auth = subscription` (supported).
  *   - Claude subscription, Pro / Max (individual) → not supported (Team/Enterprise only).
- *   - Anthropic Console login → not supported yet.
+ *   - Anthropic Console login (`/login` → Console account) → `auth = console` (supported): the
+ *     API key Claude Code created is read from its keychain (lib/console-key.ts). A
+ *     `claude auth login --console` profile creates no key → not supported yet.
  *   - Third-party provider (Bedrock / Vertex / Foundry) → not supported yet (no gateway door).
  * An Anthropic API key always works (`auth = api-key`, the default).
  *
@@ -16,6 +18,7 @@
  *
  * Pure apart from the injected deps, so every arm is unit-tested.
  */
+import { AGENT_AUTHS } from "./subscription-login.js";
 const PROVIDER_SWITCHES = [
     ["CLAUDE_CODE_USE_BEDROCK", "bedrock"],
     ["CLAUDE_CODE_USE_VERTEX", "vertex"],
@@ -60,14 +63,15 @@ export function unsupportedReason(login) {
         case "individual":
             return `your Claude ${login.plan} plan is a personal plan — Mnemom supports subscription login on Team and Enterprise plans only`;
         case "console":
-            return "Anthropic Console login is not supported yet";
+            return "your Anthropic Console login has no API key Claude Code created with /login (a `claude auth login --console` profile is not supported yet)";
         case "third-party":
             return `${PROVIDER_NAMES[login.provider]} is not supported yet`;
     }
 }
 export const MENU_SUBSCRIPTION = "Claude subscription — Team or Enterprise (your claude.ai login)";
+export const MENU_CONSOLE = "Anthropic Console — the API key your Claude Code /login created (API billing)";
 export const MENU_API_KEY = "Anthropic API key";
-const SAVED_HINT = "change it any time with `mnemom agent config set auth api-key|subscription`";
+const SAVED_HINT = `change it any time with \`mnemom agent config set auth ${AGENT_AUTHS.join("|")}\``;
 function save(deps, auth, line) {
     try {
         deps.persist(auth);
@@ -82,13 +86,27 @@ function save(deps, auth, line) {
  * Pick `auth` when nothing configured it (no --auth, MNEMOM_AGENT_AUTH or launcher.toml).
  *   - No Claude login detected → api-key, silently, nothing saved (today's behaviour).
  *   - A login we can't use → api-key, say why once, save it so the note isn't repeated.
- *   - Team/Enterprise and non-interactive → api-key, nothing saved (never switch a script's
- *     auth without asking); interactive → a two-option menu (subscription or API key), answer saved.
+ *   - Team/Enterprise, or a Console login whose key is readable, and non-interactive →
+ *     api-key, nothing saved (never switch a script's auth without asking); interactive → a
+ *     two-option menu (that login or an API key), answer saved.
  */
 export async function chooseAuth(deps) {
     const { login } = deps;
     if (login.kind === "none")
         return "api-key";
+    if (login.kind === "console" && deps.consoleKeyAvailable()) {
+        if (!deps.interactive)
+            return "api-key";
+        const picked = await deps.select("mnemom agent: Claude Code is signed in with an Anthropic Console account. How should it sign in through Mnemom?", [MENU_CONSOLE, MENU_API_KEY]);
+        if (picked === MENU_CONSOLE) {
+            return save(deps, "console", "mnemom agent: using your Anthropic Console login's API key.");
+        }
+        if (picked === MENU_API_KEY) {
+            return save(deps, "api-key", "mnemom agent: using an Anthropic API key.");
+        }
+        deps.say("mnemom agent: no choice made — using an Anthropic API key for this launch.");
+        return "api-key";
+    }
     if (login.kind !== "subscription") {
         return save(deps, "api-key", `mnemom agent: ${unsupportedReason(login)}, so this launch uses an Anthropic API key.`);
     }

package/dist/lib/subscription-login.d.ts

@@ -17,7 +17,8 @@
  * Pure apart from the injected deps, so every arm is unit-tested.
  */
 import type { LaunchShape } from "./agent.js";
-export type AgentAuth = "api-key" | "subscription";
+/** `console` = the API key Claude Code's Anthropic Console login created (lib/console-key.ts). */
+export type AgentAuth = "api-key" | "subscription" | "console";
 export declare const AGENT_AUTHS: readonly AgentAuth[];
 /** Env override for the setting (the launcher.toml `auth` key folds into it). */
 export declare const AGENT_AUTH_ENV = "MNEMOM_AGENT_AUTH";

package/dist/lib/subscription-login.js

@@ -16,7 +16,7 @@
  *
  * Pure apart from the injected deps, so every arm is unit-tested.
  */
-export const AGENT_AUTHS = ["api-key", "subscription"];
+export const AGENT_AUTHS = ["api-key", "subscription", "console"];
 /** Env override for the setting (the launcher.toml `auth` key folds into it). */
 export const AGENT_AUTH_ENV = "MNEMOM_AGENT_AUTH";
 /** Env override for the Mnemom key a subscription launch sends. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnemom/mnemom",
-  "version": "0.17.4-next.7",
+  "version": "0.17.4-next.8",
   "description": "Transparent AI agent tracing",
   "type": "module",
   "bin": {