openmausbot 0.1.65 → 0.1.67

package/dist-server/server/drivers/claude.js

@@ -12,10 +12,11 @@ import { createHash, randomBytes } from "node:crypto";
 import { chmodSync, mkdtempSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import { createServer as createNetServer } from "node:net";
 import { homedir, tmpdir } from "node:os";
-import { join, dirname } from "node:path";
+import { join, dirname, isAbsolute, normalize } from "node:path";
 import { DATA_DIR, stripWorkspaceCredentialEnv } from "../config.js";
 import { augmentedPath } from "../env-path.js";
 import { brokerSocketPath, describeSpawnFailure, execCli, killCliTree, spawnCli } from "../procs.js";
+import { ClaudeLoginController } from "./claude-login-auth.js";
 import { computerProxyEnv } from "../container-computer.js";
 import { newEventId, newId } from "../contracts.js";
 import { classifyError, computeBackoff, interruptibleDelay, RETRY_MAX_ATTEMPTS } from "./retry.js";
@@ -29,19 +30,61 @@ import { SPAWNED_PROXIES } from "../proxy-paths.js";
  * backends over time. Presence checks also accept stale credentials. The CLI's
  * own machine-readable auth command is the source of truth for every backend.
  */
-export function claudeSignedIn(cli, env, run = execCli) {
+function claudeAuthStatus(cli, env, run = execCli) {
     return new Promise((resolve) => {
-        run(cli, ["auth", "status", "--json"], { timeout: 8000, env }, (_error, stdout) => {
+        run(cli, ["auth", "status", "--json"], { timeout: 8000, maxBuffer: 65_536, env }, (_error, stdout) => {
             try {
                 const status = JSON.parse(stdout);
-                resolve(typeof status === "object" && status !== null && "loggedIn" in status && status.loggedIn === true);
+                if (!status || typeof status !== "object" || !("loggedIn" in status) || status.loggedIn !== true) {
+                    return resolve({ authenticated: false });
+                }
+                // Only display identity fields, never the CLI's full auth response.
+                const identity = status;
+                const boundedText = (value, max) => typeof value === "string" && value.trim().length > 0 && value.length <= max && !/[\p{Cc}\p{Cf}]/u.test(value)
+                    ? value.trim() : undefined;
+                const candidateEmail = boundedText(identity.email, 254);
+                const email = candidateEmail && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(candidateEmail) ? candidateEmail : undefined;
+                const organization = boundedText(identity.orgName, 160);
+                resolve({
+                    authenticated: true,
+                    ...(email || organization ? { account: { ...(email ? { email } : {}), ...(organization ? { organization } : {}) } } : {}),
+                });
             }
             catch {
-                resolve(false);
+                resolve({ authenticated: false });
             }
         });
     });
 }
+export async function claudeSignedIn(cli, env, run = execCli) {
+    return (await claudeAuthStatus(cli, env, run)).authenticated;
+}
+/** Parent-session credentials/routing that a named account must not inherit.
+ * Shared with terminal sign-in instructions so login and turns select alike. */
+export const CLAUDE_ACCOUNT_ENV_KEYS = [
+    "CLAUDE_CODE_OAUTH_TOKEN",
+    "CLAUDE_CODE_OAUTH_REFRESH_TOKEN",
+    "CLAUDE_CODE_OAUTH_SCOPES",
+    "CLAUDE_CODE_OAUTH_TOKEN_FILE_DESCRIPTOR",
+    "CLAUDE_CODE_API_KEY_FILE_DESCRIPTOR",
+    "ANTHROPIC_API_KEY",
+    "ANTHROPIC_AUTH_TOKEN",
+    "ANTHROPIC_BASE_URL",
+    "ANTHROPIC_CUSTOM_HEADERS",
+    "CLAUDE_CODE_USE_BEDROCK",
+    "CLAUDE_CODE_USE_VERTEX",
+    "CLAUDE_CODE_USE_FOUNDRY",
+];
+/** Resolve the CLI's config location without changing HOME or Keychain. */
+export function resolveClaudeConfigDir(configDir, env = process.env) {
+    const home = env.HOME || env.USERPROFILE || homedir();
+    const configured = configDir?.trim() || env.CLAUDE_CONFIG_DIR?.trim() || join(home, ".claude");
+    const expanded = configured === "~" ? home : configured.startsWith("~/") ? join(home, configured.slice(2)) : configured;
+    if (!isAbsolute(expanded) || /[\p{Cc}\p{Cf}]/u.test(expanded)) {
+        throw new Error("claude: configDir must be an absolute path or start with ~/");
+    }
+    return normalize(expanded);
+}
 /** Whether a stream frame is the CLI reporting that it has no login.
  *
  * The CLI flags its own api-error frames (`error`, `is_api_error_message`);
@@ -63,8 +106,21 @@ export function claudeAuthFailure(frame, text) {
  * Keeping the probe and turn environments identical prevents setup from
  * claiming an API-key login that the turn itself would deliberately remove.
  */
-function claudeEnvironment(model, source = process.env) {
+function claudeEnvironment(model, source = process.env, configDir, instanceEnvironment = {}) {
     const env = { ...source, PATH: augmentedPath(), NPM_CONFIG_LOGLEVEL: "error" };
+    if (configDir?.trim()) {
+        env.CLAUDE_CONFIG_DIR = resolveClaudeConfigDir(configDir, env);
+        for (const key of CLAUDE_ACCOUNT_ENV_KEYS) {
+            // Explicit custom endpoint settings still work; subscription OAuth
+            // always belongs to this account's CLI-managed login, never its parent.
+            if (key.startsWith("CLAUDE_CODE_OAUTH_") || key.endsWith("_FILE_DESCRIPTOR") || !Object.hasOwn(instanceEnvironment, key)) {
+                delete env[key];
+            }
+        }
+    }
+    else if (env.CLAUDE_CONFIG_DIR) {
+        env.CLAUDE_CONFIG_DIR = resolveClaudeConfigDir(undefined, env);
+    }
     delete env.CLAUDECODE;
     delete env.CLAUDE_CODE_ENTRYPOINT;
     // The harness process may hold workspace credentials (xai/box/voice keys,
@@ -97,11 +153,6 @@ async function resolveClaudeTurnModel(model, env) {
     }
     return resolveInjectId(model, await probeLocalInjects(env)) ?? model;
 }
-function claudeConfigDir(env) {
-    if (env.CLAUDE_CONFIG_DIR)
-        return env.CLAUDE_CONFIG_DIR;
-    return join(env.HOME || env.USERPROFILE || homedir(), ".claude");
-}
 function extrasFromUnknown(value) {
     if (!Array.isArray(value))
         return [];
@@ -127,7 +178,7 @@ function extrasFromUnknown(value) {
 export function readClaudeModelCatalog(env = process.env) {
     let settings = {};
     try {
-        settings = JSON.parse(readFileSync(join(claudeConfigDir(env), "settings.json"), "utf8"));
+        settings = JSON.parse(readFileSync(join(resolveClaudeConfigDir(undefined, env), "settings.json"), "utf8"));
     }
     catch {
         return STATIC_CLAUDE_MODELS;
@@ -446,8 +497,14 @@ function decodeConfig(raw) {
     }
     const tools = decodeToolList(o.tools, "tools");
     const disallowedTools = decodeToolList(o.disallowedTools, "disallowedTools");
+    if (o.configDir !== undefined && typeof o.configDir !== "string")
+        throw new Error("claude: configDir must be a string");
+    const configDir = typeof o.configDir === "string" ? o.configDir.trim() : undefined;
+    if (configDir)
+        resolveClaudeConfigDir(configDir);
     return {
         cli: typeof o.cli === "string" ? o.cli : "claude",
+        ...(configDir ? { configDir } : {}),
         permissionMode: mode ?? "acceptEdits",
         ...(tools !== undefined ? { tools } : {}),
         ...(disallowedTools !== undefined ? { disallowedTools } : {}),
@@ -523,7 +580,8 @@ export const ClaudeDriver = {
     defaultConfig: () => decodeConfig({}),
     async create(input) {
         const { instanceId, config } = input;
-        const catalogEnv = { ...process.env, ...input.environment };
+        const environment = (model) => claudeEnvironment(model, { ...process.env, ...input.environment }, config.configDir, input.environment);
+        const catalogEnv = environment();
         let models = STATIC_CLAUDE_MODELS;
         const refreshModels = async () => {
             try {
@@ -659,7 +717,7 @@ export const ClaudeDriver = {
             if (config.disallowedTools?.length) {
                 args.push("--disallowedTools", config.disallowedTools.join(","));
             }
-            const turnEnvironment = { ...process.env, ...input.environment };
+            const turnEnvironment = environment();
             const turnModel = await resolveClaudeTurnModel(turn.model, turnEnvironment);
             const injected = applyClaudeInject({ ...turnEnvironment }, turnModel);
             if (injected.model)
@@ -762,7 +820,7 @@ export const ClaudeDriver = {
                 args.push("--mcp-config", mcpConfigPath);
                 args.push("--allowedTools", allowed.join(","));
             }
-            const env = claudeEnvironment(turnModel, turnEnvironment);
+            const env = environment(turnModel);
             // Our approvals and browser credentials expire at the user-turn
             // boundary. Native background workers cannot outlive that boundary;
             // parallel bot work must use the harness's durable delegate_bot path.
@@ -779,6 +837,7 @@ export const ClaudeDriver = {
                 cwd,
                 model: injected.model ?? null,
                 base: env.ANTHROPIC_BASE_URL ?? null,
+                configDir: env.CLAUDE_CONFIG_DIR ?? null,
             });
             // Reuse the live process when it is idle, unchanged, and is the session
             // the harness wants resumed. Anything else: close it and spawn fresh
@@ -1229,18 +1288,21 @@ export const ClaudeDriver = {
                 return false;
             return writeUser(s, threadId, claudeUserMessage(text, undefined));
         };
+        // Sign in from Settings: the unmodified CLI's own login, driven over pipes
+        // (server/drivers/claude-login-auth.ts). Same environment as every turn.
+        const login = new ClaudeLoginController({ cli: config.cli, environment, onAuthenticated: async () => { await refreshModels(); } });
         const snapshot = async () => {
-            const env = claudeEnvironment(undefined, { ...process.env, ...input.environment });
+            const env = environment();
             const version = await new Promise((resolve) => {
                 execCli(config.cli, ["--version"], { timeout: 8000, env }, (err, stdout) => resolve(err ? null : stdout.trim()));
             });
             if (!version)
                 return { state: "unavailable", reason: `\`${config.cli}\` CLI not found` };
-            const authenticated = await claudeSignedIn(config.cli, env);
+            const auth = await claudeAuthStatus(config.cli, env);
             // claudeEnvironment strips ANTHROPIC_API_KEY, so turns run on the
             // CLI's own login (Pro/Max): the cost it reports is what the call
             // WOULD bill, not a charge
-            return { state: "available", version, authenticated, billing: "subscription" };
+            return { state: "available", version, ...auth, billing: "subscription" };
         };
         /** One-shot Claude call with the prompt on stdin, never argv. Approval
          * summaries can contain paths, commands, or secrets, so the generic
@@ -1249,7 +1311,7 @@ export const ClaudeDriver = {
         const generateReview = (prompt, signal) => new Promise((resolve, reject) => {
             const child = spawnCli(config.cli, ["-p", "--model", "claude-haiku-4-5", "--output-format", "text"], {
                 stdio: ["pipe", "pipe", "pipe"],
-                env: claudeEnvironment("claude-haiku-4-5", { ...process.env, ...input.environment }),
+                env: environment("claude-haiku-4-5"),
             });
             let stdout = "";
             let stderr = "";
@@ -1310,6 +1372,10 @@ export const ClaudeDriver = {
             },
             refreshModels,
             snapshot,
+            startAuthentication: () => login.start(),
+            getAuthentication: (flowId) => login.get(flowId),
+            completeAuthentication: (flowId, code) => login.complete(flowId, code),
+            cancelAuthentication: () => login.cancel(),
             adapter: {
                 provider: DRIVER_KIND,
                 capabilities: {

package/dist-server/server/environment.js

@@ -100,6 +100,7 @@ export function environmentDescriptor(input) {
         capabilities: {
             remoteSessions: true,
             selfUpdate: input.desktopManaged ? "desktop-managed" : "operator",
+            emailSignIn: input.emailSignIn === true,
         },
     };
 }

package/dist-server/server/harness/bus.js

@@ -12,7 +12,7 @@ import { newId } from "../contracts.js";
 const INCOMPLETE_LOG_MESSAGE = "Canonical event history is incomplete: OpenMausBot could not write one or more events to disk. Live updates will continue.";
 export class EventBus {
     listeners = new Set();
-    unsubscribes = [];
+    unsubscribes = new Map();
     pendingLogWarnings = new Map();
     appendLog;
     constructor(appendLog = appendFileSync) {
@@ -20,6 +20,7 @@ export class EventBus {
     }
     attach(instances) {
         for (const instance of instances) {
+            this.detach(instance.instanceId);
             const unsub = instance.adapter.onEvent((event) => {
                 // hard invariant borrowed from correlateRuntimeEventWithInstance:
                 // an adapter may only emit events for its own driver kind
@@ -29,7 +30,7 @@ export class EventBus {
                 }
                 this.publish({ ...event, providerInstanceId: instance.instanceId });
             });
-            this.unsubscribes.push(unsub);
+            this.unsubscribes.set(instance.instanceId, unsub);
         }
     }
     publish(event) {
@@ -80,7 +81,11 @@ export class EventBus {
         return () => this.listeners.delete(listener);
     }
     detachAll() {
-        for (const unsub of this.unsubscribes.splice(0))
-            unsub();
+        for (const id of this.unsubscribes.keys())
+            this.detach(id);
+    }
+    detach(instanceId) {
+        this.unsubscribes.get(instanceId)?.();
+        this.unsubscribes.delete(instanceId);
     }
 }

package/dist-server/server/harness/registry.js

@@ -35,6 +35,8 @@ export class ProviderRegistry {
     }
     async load(configs) {
         for (const [instanceId, entry] of Object.entries(configs)) {
+            // Account edits replace only their own process/session state.
+            await this.dispose(instanceId);
             const driver = this.driversByKind.get(entry.driver);
             if (!driver) {
                 this.byId.set(instanceId, {
@@ -205,7 +207,13 @@ export class ProviderRegistry {
                 access: driver?.metadata.access ?? "subscription",
                 install: driver?.install,
                 authentication: inst.startAuthentication
-                    ? { method: inst.getAuthentication ? "device-code" : "browser" }
+                    ? {
+                        method: inst.getAuthentication && inst.completeAuthentication
+                            ? "paste-code" // a link to open, then a code pasted back (Claude)
+                            : inst.getAuthentication
+                                ? "device-code" // a code to enter at the provider's page (Codex)
+                                : "browser", // a link and a callback URL (managed engines)
+                    }
                     : undefined,
                 cli: this.cliByInstance.get(inst.instanceId),
                 cliDefault: cliDefaultOf(driver),
@@ -221,4 +229,10 @@ export class ProviderRegistry {
         this.byId.clear();
         this.cliByInstance.clear();
     }
+    async dispose(instanceId) {
+        const entry = this.byId.get(instanceId);
+        this.byId.delete(instanceId);
+        this.cliByInstance.delete(instanceId);
+        await entry?.live?.dispose();
+    }
 }