imprint-mcp 0.7.0 → 0.7.2

package/src/imprint/auth-verifier.ts

@@ -4,9 +4,20 @@
  * the requested actions.
  */
 
+import {
+  AUTH_DISCOVERY_POOL_KEY,
+  type AuthBrowserAction,
+  AuthBrowserActionSchema,
+  type AuthBrowserObservation,
+} from './auth-browser-discovery.ts';
 import { runWorkflowWithLadder } from './backend-ladder.ts';
-import type { CdpBrowserFetch, CdpPageSnapshot } from './cdp-browser-fetch.ts';
+import {
+  type CdpBrowserFetch,
+  type CdpPageSnapshot,
+  createCdpBrowserFetch,
+} from './cdp-browser-fetch.ts';
 import { abortSignalError, withAbortSignal } from './concurrency.ts';
+import { redactFreeformText } from './freeform-redact.ts';
 import { createLog } from './log.ts';
 import type { CredentialStore } from './runtime.ts';
 
@@ -30,6 +41,9 @@ export interface AuthActionResult {
   status?: number;
   responseBodyPreview?: string;
   durationMs: number;
+  requestStageFacts?: Extract<import('./types.ts').ToolResult, { ok: false }>['requestStageFacts'];
+  authExecution?: Extract<import('./types.ts').ToolResult, { ok: false }>['authExecution'];
+  responseObservations?: Awaited<ReturnType<LadderRunner>>['responseObservations'];
 }
 
 interface AuthPageInspection {
@@ -43,38 +57,107 @@ interface AuthPageInspection {
 }
 
 export class AuthVerifier {
-  private readonly cdpPool = new Map<string, CdpBrowserFetch>();
+  private cdpPool = new Map<string, CdpBrowserFetch>();
+  private readonly pendingPools = new Set<Map<string, CdpBrowserFetch>>();
+  private readonly retiredPools = new Set<Map<string, CdpBrowserFetch>>();
+  private readonly closedBrowsers = new WeakSet<CdpBrowserFetch>();
+  private poolRelease: Promise<void> = Promise.resolve();
   private continuation: Record<string, unknown> | undefined;
   private readonly sensitiveValues = new Set<string>();
+  private readonly abort = new AbortController();
+  private lastAction?: Pick<AuthActionResult, 'action' | 'ok' | 'error' | 'nextAction' | 'status'>;
+
+  /** Facts for a recovery turn; never expose carried state or browser values. */
+  get state(): {
+    browserActive: boolean;
+    hasContinuation: boolean;
+    lastAction?: Pick<AuthActionResult, 'action' | 'ok' | 'error' | 'nextAction' | 'status'>;
+  } {
+    return {
+      browserActive: this.cdpPool.size > 0,
+      hasContinuation: this.continuation !== undefined,
+      lastAction: this.lastAction,
+    };
+  }
 
   constructor(
     private readonly workflowPath: string,
-    private readonly credentials: CredentialStore,
+    private credentials: CredentialStore,
+    private readonly discoveryUrl?: string,
   ) {
     this.rememberSensitiveValues(credentials.values);
   }
 
+  /** Refresh future request inputs without discarding the live page or challenge. */
+  updateCredentials(credentials: CredentialStore): void {
+    if (this.abort.signal.aborted) throw abortSignalError(this.abort.signal);
+    this.credentials = credentials;
+    this.rememberSensitiveValues(credentials.values);
+  }
+
   async runAction(
     action: string,
     parameters: Record<string, string | number | boolean> = {},
     options: { freshSession?: boolean; cleanSession?: boolean; signal?: AbortSignal } = {},
   ): Promise<AuthActionResult> {
-    if (options.signal?.aborted) throw abortSignalError(options.signal);
+    const signal = options.signal
+      ? AbortSignal.any([options.signal, this.abort.signal])
+      : this.abort.signal;
+    if (signal.aborted) throw abortSignalError(signal);
+    await withAbortSignal(() => this.poolRelease, signal);
     if (options.freshSession || options.cleanSession) await this.reset();
     this.rememberSensitiveValues(parameters);
     const previousContinuation = this.continuation;
+    const pool = this.cdpPool;
     const startedAt = Date.now();
-    const ladder = await ladderRunner({
-      workflowPath: this.workflowPath,
-      params: { ...parameters, action },
-      credentials: options.cleanSession
-        ? { ...this.credentials, cookies: [], storage: [] }
-        : this.credentials,
-      cdpPool: this.cdpPool,
-      forceBackend: 'cdp-replay',
-      initialState: this.continuation,
-      signal: options.signal,
-    });
+    // A cancelled ladder can still be unwinding an uninterruptible CDP await.
+    // Detach its map before returning to the caller: no later action may borrow
+    // a browser that the older ladder can still close or evict.
+    const abort = (): void => {
+      if (this.cdpPool === pool) {
+        this.lastAction = { action, ok: false, error: 'CANCELLED' };
+      }
+      void this.retirePool(pool);
+    };
+    signal.addEventListener('abort', abort, { once: true });
+    if (signal.aborted) {
+      abort();
+      signal.removeEventListener('abort', abort);
+      throw abortSignalError(signal);
+    }
+    this.pendingPools.add(pool);
+    let ladder: Awaited<ReturnType<LadderRunner>>;
+    try {
+      ladder = await withAbortSignal(
+        () =>
+          Promise.resolve()
+            .then(() => {
+              if (signal.aborted) throw abortSignalError(signal);
+              return ladderRunner({
+                workflowPath: this.workflowPath,
+                params: { ...parameters, action },
+                credentials: options.cleanSession
+                  ? { ...this.credentials, cookies: [], storage: [] }
+                  : this.credentials,
+                cdpPool: pool,
+                forceBackend: 'cdp-replay',
+                initialState: previousContinuation,
+                signal,
+              });
+            })
+            .finally(async () => {
+              if (signal.aborted || pool !== this.cdpPool) await this.closePool(pool);
+              this.pendingPools.delete(pool);
+              this.retiredPools.delete(pool);
+            }),
+        signal,
+      );
+    } finally {
+      signal.removeEventListener('abort', abort);
+    }
+    if (signal.aborted) throw abortSignalError(signal);
+    if (pool !== this.cdpPool)
+      throw new DOMException('Authentication action context was replaced', 'AbortError');
     const durationMs = Date.now() - startedAt;
     const result = ladder.result;
 
@@ -99,6 +182,37 @@ export class AuthVerifier {
         ? undefined
         : this.sanitizeOptional(result.responseBodyPreview),
       durationMs,
+      requestStageFacts: result.ok ? undefined : result.requestStageFacts,
+      authExecution:
+        result.ok || !result.authExecution
+          ? undefined
+          : {
+              ...result.authExecution,
+              ...(result.authExecution.lastFailure
+                ? {
+                    lastFailure: {
+                      error: this.sanitize(result.authExecution.lastFailure.error),
+                      message: this.sanitize(result.authExecution.lastFailure.message),
+                    },
+                  }
+                : {}),
+            },
+      responseObservations: ladder.responseObservations?.map(
+        ({ redactedBodyPreview: _preview, ...facts }) => ({
+          ...facts,
+          ...(facts.contentType ? { contentType: this.sanitize(facts.contentType) } : {}),
+          ...(facts.topLevelKeys
+            ? { topLevelKeys: facts.topLevelKeys.map((key) => this.sanitize(key)) }
+            : {}),
+        }),
+      ),
+    };
+    this.lastAction = {
+      action,
+      ok: actionResult.ok,
+      error: actionResult.error,
+      nextAction: actionResult.nextAction,
+      status: actionResult.status,
     };
     log(
       `action=${JSON.stringify(action)} backend=${ladder.usedBackend} ok=${result.ok}${
@@ -111,6 +225,10 @@ export class AuthVerifier {
   async inspectPage(
     options: { maxChars?: number; includeCookies?: boolean; signal?: AbortSignal } = {},
   ): Promise<AuthPageInspection> {
+    const signal = options.signal
+      ? AbortSignal.any([options.signal, this.abort.signal])
+      : this.abort.signal;
+    if (signal.aborted) throw abortSignalError(signal);
     const browser = Array.from(this.cdpPool.values()).at(-1);
     if (!browser) {
       return { ok: false, message: 'No active verification browser session exists.' };
@@ -121,7 +239,7 @@ export class AuthVerifier {
     }
 
     const maxChars = Math.max(256, Math.min(20_000, Math.floor(options.maxChars ?? 8_000)));
-    const snapshot = await withAbortSignal(() => inspectPage.call(browser), options.signal);
+    const snapshot = await withAbortSignal(() => inspectPage.call(browser), signal);
     const bodyText = this.sanitize(snapshot.bodyText);
     return {
       ok: true,
@@ -146,16 +264,112 @@ export class AuthVerifier {
     };
   }
 
+  async interactBrowser(
+    input: AuthBrowserAction,
+    callerSignal?: AbortSignal,
+  ): Promise<AuthBrowserObservation> {
+    const signal = callerSignal
+      ? AbortSignal.any([callerSignal, this.abort.signal])
+      : this.abort.signal;
+    if (signal.aborted) throw abortSignalError(signal);
+    await withAbortSignal(() => this.poolRelease, signal);
+    const action = AuthBrowserActionSchema.parse(input);
+    if ('value' in action) {
+      const credential = /^\$\{credential\.([^}]+)\}$/.exec(action.value);
+      if (credential) {
+        const value = this.credentials.values[credential[1] ?? ''];
+        if (value === undefined)
+          throw new Error('The requested credential is unavailable; ask the human for it.');
+        action.value = value;
+      }
+      if (action.action === 'fill' || credential) this.rememberSensitiveValues(action.value);
+    }
+    const pool = this.cdpPool;
+    let browser = Array.from(pool.values()).at(-1);
+    if (!browser) {
+      const url = action.action === 'navigate' ? action.url : this.discoveryUrl;
+      if (!url)
+        throw new Error('No verification browser exists; supply a discovery navigation URL.');
+      browser = createCdpBrowserFetch({
+        baseUrl: url,
+        bootstrapUrl: url,
+        headed: true,
+        seedCookies: this.credentials.cookies,
+        seedStorage: this.credentials.storage,
+      });
+      pool.set(AUTH_DISCOVERY_POOL_KEY, browser);
+    }
+    const interactBrowser = browser.interactBrowser?.bind(browser);
+    if (!interactBrowser)
+      throw new Error('The active verification browser cannot perform discovery.');
+    const abort = (): void => {
+      void this.retirePool(pool);
+    };
+    signal.addEventListener('abort', abort, { once: true });
+    try {
+      if (signal.aborted) throw abortSignalError(signal);
+      const observation = await withAbortSignal(() => interactBrowser(action), signal);
+      if (pool !== this.cdpPool || signal.aborted) throw abortSignalError(signal);
+      const replacements = new Map(
+        Object.entries(this.credentials.values).map(([name, value]) => [
+          value,
+          `\${credential.${name}}`,
+        ]),
+      );
+      const protect = (value: unknown): unknown => {
+        if (typeof value === 'string')
+          return this.sanitize(redactFreeformText(value, replacements).redacted);
+        if (Array.isArray(value)) return value.map(protect);
+        if (value && typeof value === 'object')
+          return Object.fromEntries(
+            Object.entries(value).map(([key, item]) => [key, protect(item)]),
+          );
+        return value;
+      };
+      return protect(observation) as AuthBrowserObservation;
+    } catch (error) {
+      if (signal.aborted) throw abortSignalError(signal);
+      throw new Error(this.sanitize(error instanceof Error ? error.message : String(error)));
+    } finally {
+      signal.removeEventListener('abort', abort);
+    }
+  }
+
   async drain(): Promise<void> {
+    this.abort.abort(new DOMException('Authentication verifier closed', 'AbortError'));
     await this.reset();
+    await Promise.allSettled(Array.from(this.retiredPools, (pool) => this.closePool(pool)));
+    this.sensitiveValues.clear();
+    this.lastAction = undefined;
   }
 
   private async reset(): Promise<void> {
-    for (const browser of this.cdpPool.values()) {
-      await browser.close().catch(() => {});
+    await this.retirePool(this.cdpPool);
+    await this.poolRelease;
+  }
+
+  private retirePool(pool: Map<string, CdpBrowserFetch>): Promise<void> {
+    if (this.cdpPool === pool) {
+      this.cdpPool = new Map();
+      this.continuation = undefined;
     }
-    this.cdpPool.clear();
-    this.continuation = undefined;
+    this.retiredPools.add(pool);
+    const release = this.closePool(pool);
+    this.poolRelease = Promise.allSettled([this.poolRelease, release]).then(() => {});
+    if (!this.pendingPools.has(pool)) void release.then(() => this.retiredPools.delete(pool));
+    return release;
+  }
+
+  private async closePool(pool: Map<string, CdpBrowserFetch>): Promise<void> {
+    const browsers = new Set(pool.values());
+    pool.clear();
+    await Promise.allSettled(
+      Array.from(browsers, async (browser) => {
+        if (this.closedBrowsers.has(browser)) return;
+        this.closedBrowsers.add(browser);
+        await browser.close();
+      }),
+    );
   }
 
   private rememberSensitiveValues(value: unknown, seen = new Set<object>()): void {

package/src/imprint/authentication-interaction.ts

@@ -0,0 +1,137 @@
+/** Connect agent-selected auth work to the existing live auth compiler. */
+import { randomUUID } from 'node:crypto';
+import { readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { AuthCompileContext, type compileAuthAgent } from './auth-compile-agent.ts';
+import { isCredentialReference } from './credential-extract.ts';
+import { credentialObservation } from './credential-observation.ts';
+import { loadSiteCredentials } from './credential-store.ts';
+import type { LLMOptions } from './llm.ts';
+import type { RunDeadlineRef } from './provider-retry.ts';
+import type { Session } from './types.ts';
+import { currentUserInteraction } from './user-interaction.ts';
+
+export function attachRecordedAuthentication(options: {
+  session: Session;
+  sessionPath: string;
+  root: string;
+  values: Record<string, string>;
+  llmConfig?: LLMOptions;
+  runDeadline?: RunDeadlineRef;
+  compile?: typeof compileAuthAgent;
+  report?: (message: string) => void;
+}): void {
+  const interaction = currentUserInteraction();
+  if (!interaction) return;
+  const contexts = new Map<string, { context: AuthCompileContext; outDir: string }>();
+  const workspaces = new Set<string>();
+  const recordingRevision = randomUUID();
+  const refreshMetadata = (contextRef: string, outDir: string): void => {
+    const metadata: Parameters<typeof interaction.updateAuthenticationContext>[1] = {
+      recordingRef: options.sessionPath,
+      recordingRevision,
+      workflowPath: join(outDir, 'workflow.json'),
+      evidenceRefs: [
+        join(outDir, '.auth-evidence-session.json'),
+        join(outDir, '.auth-live-discovery.json'),
+      ],
+    };
+    try {
+      const stat = statSync(join(outDir, 'workflow.json'));
+      metadata.workflowRevision = `${stat.mtimeMs}:${stat.size}`;
+    } catch {
+      /* No artifact has been written yet. */
+    }
+    try {
+      const attempt: unknown = JSON.parse(
+        readFileSync(join(outDir, '.auth-verification-attempt.json'), 'utf8'),
+      );
+      if (attempt && typeof attempt === 'object') {
+        const value = attempt as Record<string, unknown>;
+        if (typeof value.action === 'string') metadata.latestAction = value.action;
+        if (typeof value.ok === 'boolean') metadata.latestOk = value.ok;
+        metadata.latestStatus = typeof value.status === 'number' ? value.status : undefined;
+        metadata.latestError = typeof value.error === 'string' ? value.error : undefined;
+      }
+    } catch {
+      /* Discovery need not have a compiled action attempt. */
+    }
+    interaction.updateAuthenticationContext(contextRef, metadata);
+  };
+  interaction.addCleanup(async () => {
+    await Promise.allSettled(Array.from(contexts.values(), ({ context }) => context.dispose()));
+    contexts.clear();
+  });
+  interaction.setAuthenticate(async (plan, signal) => {
+    const knownSeqs = new Set(options.session.requests.map(({ seq }) => seq));
+    if (
+      [...plan.credentialRequestSeqs, ...plan.authRequestSeqs].some((seq) => !knownSeqs.has(seq))
+    ) {
+      return {
+        status: 'failed',
+        message: 'Authentication plan cites a request outside the selected recording.',
+      };
+    }
+    options.report?.(
+      `authenticating with ${plan.toolName}; questions appear in the terminal when needed`,
+    );
+    const compile = options.compile ?? (await import('./auth-compile-agent.ts')).compileAuthAgent;
+    // UserInteraction resolves/validates identity before queuing the operation.
+    // Its legacy label mapping remains compatible, while explicit refs can cross labels.
+    const contextRef = plan.contextRef;
+    if (!contextRef) throw new Error('Authentication host requires a resolved contextRef.');
+    let retained = contexts.get(contextRef);
+    if (!retained) {
+      const legacyDir = join(options.root, plan.toolName);
+      const outDir = workspaces.has(legacyDir)
+        ? join(options.root, `${plan.toolName}-${contextRef}`)
+        : legacyDir;
+      retained = { context: new AuthCompileContext(), outDir };
+      contexts.set(contextRef, retained);
+      workspaces.add(outDir);
+    }
+    const { context, outDir } = retained;
+    refreshMetadata(contextRef, outDir);
+    if (process.env.IMPRINT_CREDENTIAL_DIAGNOSTICS_PATH) {
+      try {
+        const stored = await loadSiteCredentials(options.session.site);
+        const values = Object.fromEntries(
+          Object.entries(options.values).filter(([, value]) => !isCredentialReference(value)),
+        );
+        const observation = credentialObservation(
+          { ...stored, values: { ...stored.values, ...values } },
+          'authentication-context-boundary',
+        );
+        if (observation)
+          interaction.updateAuthenticationContext(contextRef, {
+            credentialRevision: observation.revision,
+          });
+      } catch {
+        /* Optional context metadata cannot affect authentication. */
+      }
+    }
+    const result = await compile({
+      context,
+      site: options.session.site,
+      session: options.session,
+      sessionPath: options.sessionPath,
+      outDir,
+      authToolPlan: plan,
+      teachCredentials: { site: options.session.site, values: options.values },
+      llmConfig: options.llmConfig,
+      runDeadline: options.runDeadline,
+      signal,
+      onProgress: (progress) => {
+        refreshMetadata(contextRef, outDir);
+        options.report?.(`${plan.toolName}: ${progress.toolName ?? progress.phase}`);
+      },
+    });
+    refreshMetadata(contextRef, outDir);
+    return {
+      contextRef,
+      status: result.success ? 'authenticated' : 'failed',
+      message: result.message,
+      ...(result.workflowPath ? { workflowPath: result.workflowPath } : {}),
+    };
+  });
+}